import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.pyplot as plt
import matplotlib as mpl
from IPython.display import display
from ortools.linear_solver import pywraplp
import time
import logging
import numpy as np

def opt_production_plan(data):
  logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
  # Create the mip solver with the SCIP backend.
  m = pywraplp.Solver.CreateSolver('SCIP')
  logging.debug("Solver created.")
  # decision variables
  obj = m.NumVar(0, 1000000000, 'obj')

  setup = []
  production = []
  inventory = []
  for product in range(len(data.demands)):
    setup_temp = []
    production_temp = []
    inventory_temp = []
    for day in range(len(data.days)):
        suffix = '_{}_{}'.format(product, day)
        setup_temp.append(m.BoolVar('setup' + suffix))
        production_temp.append(m.NumVar(0, 100000, 'production' + suffix))
        inventory_temp.append(m.NumVar(0, 100000, 'inventory' + suffix))

    setup.append(setup_temp)
    production.append(production_temp)
    inventory.append(inventory_temp)
  logging.debug("Variables created.")


  # constraints
  m.Add(obj >= sum(
      sum(production[product]) * data.production_cost[product] +
      sum(setup[product]) * data.setup_cost[product] + 
      sum(inventory[product][:-1] * data.inventory_cost[product])
        for product in range(len(data.demands))))
  logging.debug("Objective function added.")
  # Demand constraint
  for product in range(len(data.demands)):
    for day in data.days:
      # Setup constraint
      #logging.debug(f"Adding setup constraint for product {product}, day {day}.")
      m.Add(production[product][day] <= 100000 * setup[product][day])
      #logging.debug(f"Setup constraint for product {product}, day {day} added.")

      if day != 0:
        if day - data.lead_time[product] >= 0:
            m.Add(inventory[product][day-1] + production[product][day - data.lead_time[product]] == \
                  (data.demands[product][day] + sum(data.parts[unit][product] * production[unit][day] for unit in range(len(data.demands)))) + inventory[product][day])
        else:
          m.Add(inventory[product][day-1] == (data.demands[product][day] + sum(data.parts[unit][product] * production[unit][day] for unit in range(len(data.demands)))) + inventory[product][day])
      else:
        m.Add(data.first_inventory[product] == (data.demands[product][0] + sum(data.parts[unit][product] * production[unit][0] for unit in range(len(data.demands)))) + inventory[product][0])
      #logging.debug(f"Demand balance constraint for product {product}, day {day} added.")

  logging.debug("All constraints added.")

  # objective function
  m.Minimize(obj)
  logging.debug("Objective function set to minimize.")
  # solving the model
  status = m.Solve()
  logging.debug(f"Solving the model, solver status: {status}")
  if status == pywraplp.Solver.OPTIMAL:

      PRODUCTION_PLAN = {}
      for product in range(len(data.demands)):
        PRODUCTION_PLAN_temp = {}
        for m_idx, day in enumerate(data.days):
            PRODUCTION_PLAN_temp[day] = {
                'product ' + str(product):   production[product][m_idx].solution_value(), \
                'setup':                     setup[product][m_idx].solution_value(), \
                'inventory':                 inventory[product][m_idx].solution_value()
                }
        PRODUCTION_PLAN[product] = PRODUCTION_PLAN_temp
      logging.debug("Optimal solution found.")
      return PRODUCTION_PLAN, obj.solution_value()

  elif status == pywraplp.Solver.FEASIBLE:
      logging.debug("Solver found a feasible solution, not necessarily optimal.")
  elif status == pywraplp.Solver.INFEASIBLE:
      logging.debug("Solver found the problem to be infeasible.")
  elif status == pywraplp.Solver.UNBOUNDED:
      logging.debug("Solver found the problem to be unbounded.")
  else:
      logging.debug("Solver ended with an unknown status.")

class ProjectData:

  def __init__(self):

    self.demands = [
            [0, 0, 0, 0, 0, 18, 15, 16, 12, 14, 19, 10, 13, 11, 17, 12],  # Table demand
            [0]*16,  # Tabletop demand (calculated)
            [0]*16,  # Leg demand (calculated)
            [0]*16,  # Beam demand (calculated)
            [0]*16,  # Screw demand (calculated)
            [0]*16,  # Plank demand (calculated)
            [0]*16,  # Bracket demand (calculated)
            [0]*16   # Glue demand (calculated)
        ]

    self.days = range(len(self.demands[0]))

    self.parts = [
            [0, 1, 4, 2, 0, 0, 0, 0],  # Table
            [0, 0, 0, 0, 8, 1, 4, 0],  # Tabletop
            [0, 0, 0, 0, 8, 4, 4, 1],  # Leg
            [0, 0, 0, 0, 4, 2, 4, 1],  # Beam
            [0, 0, 0, 0, 0, 0, 0, 0],  # Screws
            [0, 0, 0, 0, 0, 0, 0, 1],  # Plank
            [0, 0, 0, 0, 0, 0, 0, 0],  # Brackets
            [0, 0, 0, 0, 0, 0, 0, 0]   # Glue
        ]

    self.lead_time = [3, 2, 2, 3, 1, 1, 1, 1]

    self.production_cost = [100] * len(self.demands)
    self.first_inventory = [0, 20, 100, 70, 50, 100, 50, 100]
    self.inventory_cost = [20, 10, 10, 10, 5, 5, 5, 5]
    self.setup_cost = [500, 200, 200, 200, 200, 200, 200, 200]

start_time = time.time()
data = ProjectData()
PRODUCTION_PLAN, obj = opt_production_plan(data)
end_time = time.time()

run_time = end_time - start_time
'''for product in range(len(data.demands)):
    # print(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]))
  display(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]).round(0))
  print('objective is : 'xxx)'''
values = [22300, 14760, 54200, 25940, 625600, 265170, 359725, 332100]

for product in range(len(data.demands)):
    display(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]).round(0))
    print(f'partial objective is : {values[product]}')
print('final objective is : ', round(obj), '. Run time is : ', run_time)

2024-06-14 01:07:42,071 - DEBUG - Solver created.
2024-06-14 01:07:42,075 - DEBUG - Variables created.
2024-06-14 01:07:42,088 - DEBUG - Objective function added.
2024-06-14 01:07:42,105 - DEBUG - All constraints added.
2024-06-14 01:07:42,112 - DEBUG - Objective function set to minimize.
2024-06-14 01:07:49,945 - DEBUG - Solving the model, solver status: 0
2024-06-14 01:07:49,945 - DEBUG - Optimal solution found.

partial objective is : 22300

partial objective is : 14760

partial objective is : 54200

partial objective is : 25940

partial objective is : 625600

partial objective is : 265170

partial objective is : 359725

partial objective is : 332100
final objective is :  1699796 . Run time is :  7.896997690200806

class data_generator_MPS():

  def __init__(self):

    self.demands = [[0, 0, 0, 0, 0, 18, 15, 16, 12, 14, 19, 10, 13, 11, 17, 12]]

    self.days = range(len(self.demands[0]))

    self.production_rate = [1]* len(self.days)
    self.parts = [[0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0]]
    self.lead_time = [3]

    self.production_cost = [100] * len(self.demands)
    self.first_inventory = [0]
    self.inventory_cost = [20] * len(self.demands)
    self.setup_cost = [500] * len(self.demands)

start_time = time.time()
data = data_generator_MPS()
PRODUCTION_PLAN, obj = opt_production_plan(data)
end_time = time.time()

run_time = end_time - start_time
for product in range(len(data.demands)):
    # print(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]))
  display(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]).round(0))
print('objective is : ', round(obj), '. Run time is : ', run_time)

2024-06-14 01:08:05,240 - DEBUG - Solver created.
2024-06-14 01:08:05,240 - DEBUG - Variables created.
2024-06-14 01:08:05,240 - DEBUG - Objective function added.
2024-06-14 01:08:05,245 - DEBUG - All constraints added.
2024-06-14 01:08:05,246 - DEBUG - Objective function set to minimize.
2024-06-14 01:08:05,262 - DEBUG - Solving the model, solver status: 0
2024-06-14 01:08:05,264 - DEBUG - Optimal solution found.

objective is :  19900 . Run time is :  0.0328974723815918

class data_generator_MRP_tabelT():

  def __init__(self):

    self.demands = [[0, 0, 33, 0, 28, 0, 14, 29, 0, 24, 0, 29, 0, 0, 0, 0]]

    self.days = range(len(self.demands[0]))

    self.production_rate = [1]* len(self.days)
    self.parts = [[0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0]]
    
    self.lead_time = [2]

    self.first_inventory = [20]
    self.production_cost = [100] * len(self.demands)

    self.inventory_cost = [10] * len(self.demands)
    self.setup_cost = [200] * len(self.demands)

start_time = time.time()
data = data_generator_MRP_tabelT()
PRODUCTION_PLAN, obj = opt_production_plan(data)
end_time = time.time()

print('Table top obj fct: ')
run_time = end_time - start_time
for product in range(len(data.demands)):
    # print(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]))
  display(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]).round(0))
print('objective is : ', round(obj), '. Run time is : ', run_time)

2024-06-14 01:08:08,417 - DEBUG - Solver created.
2024-06-14 01:08:08,418 - DEBUG - Variables created.
2024-06-14 01:08:08,421 - DEBUG - Objective function added.
2024-06-14 01:08:08,422 - DEBUG - All constraints added.
2024-06-14 01:08:08,422 - DEBUG - Objective function set to minimize.
2024-06-14 01:08:08,422 - DEBUG - Solving the model, solver status: 0
2024-06-14 01:08:08,429 - DEBUG - Optimal solution found.

Table top obj fct:

objective is :  15300 . Run time is :  0.017823219299316406

class data_generator_MRP_leg():

  def __init__(self):

    self.demands = [[0.0, 0.0, 132.0, 0.0, 112.0, 0.0, 56.0, 116.0, 0.0, 96.0, 0.0, 116.0, 0.0, 0.0, 0.0, 0.0]
]

    self.days = range(len(self.demands[0]))

    self.production_rate = [1]* len(self.days)
    self.parts = [[0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0]]
    
    self.lead_time = [2]



    self.first_inventory = [100]
    self.production_cost = [100] * len(self.demands)

    self.inventory_cost = [10] * len(self.demands)
    self.setup_cost = [200] * len(self.demands)

start_time = time.time()
data = data_generator_MRP_leg()
PRODUCTION_PLAN, obj = opt_production_plan(data)
end_time = time.time()

run_time = end_time - start_time
for product in range(len(data.demands)):
    # print(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]))
  display(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]).round(0))
print('objective is : ', round(obj), '. Run time is : ', run_time)

2024-06-14 01:08:11,320 - DEBUG - Solver created.
2024-06-14 01:08:11,321 - DEBUG - Variables created.
2024-06-14 01:08:11,322 - DEBUG - Objective function added.
2024-06-14 01:08:11,323 - DEBUG - All constraints added.
2024-06-14 01:08:11,324 - DEBUG - Objective function set to minimize.
2024-06-14 01:08:11,324 - DEBUG - Solving the model, solver status: 0
2024-06-14 01:08:11,328 - DEBUG - Optimal solution found.

objective is :  56000 . Run time is :  0.01572895050048828

class data_generator_MRP_beam():

  def __init__(self):

    self.demands = [[0.0, 0.0, 66.0, 0.0, 56.0, 0.0, 28.0, 58.0, 0.0, 48.0, 0.0, 58.0, 0.0, 0.0, 0.0, 0.0]]

    self.days = range(len(self.demands[0]))

    self.production_rate = [1]* len(self.days)
    self.parts = [[0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0]]
    self.lead_time = [3]

    self.first_inventory = [70]
    self.production_cost = [100] * len(self.demands)

    self.inventory_cost = [10] * len(self.demands)
    self.setup_cost = [200] * len(self.demands)

start_time = time.time()
data = data_generator_MRP_beam()
PRODUCTION_PLAN, obj = opt_production_plan(data)
end_time = time.time()

run_time = end_time - start_time
for product in range(len(data.demands)):
    # print(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]))
  display(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]).round(0))
print('objective is : ', round(obj), '. Run time is : ', run_time)

2024-06-14 01:08:13,721 - DEBUG - Solver created.
2024-06-14 01:08:13,721 - DEBUG - Variables created.
2024-06-14 01:08:13,729 - DEBUG - Objective function added.
2024-06-14 01:08:13,730 - DEBUG - All constraints added.
2024-06-14 01:08:13,731 - DEBUG - Objective function set to minimize.
2024-06-14 01:08:13,733 - DEBUG - Solving the model, solver status: 0
2024-06-14 01:08:13,734 - DEBUG - Optimal solution found.

objective is :  26880 . Run time is :  0.01629495620727539

# demand for screws for each table_top, legs and beams
list1 = [13.0, 0.0, 28.0, 0.0, 14.0, 29.0, 0.0, 24.0, 0.0, 29.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
list2 = [32.0, 0.0, 112.0, 0.0, 56.0, 116.0, 0.0, 96.0, 0.0, 116.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
list3 = [0.0, 52.0, 0.0, 28.0, 58.0, 0.0, 48.0, 0.0, 58.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]

# Multiply each list by the specified factor
list1_multiplied = [num * 8 for num in list1]
list2_multiplied = [num * 8 for num in list2]
list3_multiplied = [num * 4 for num in list3]

# Combine the three lists by adding corresponding elements
combined_list = [a + b + c for a, b, c in zip(list1_multiplied, list2_multiplied, list3_multiplied)]
print(f'The demand for screws will be : {combined_list}')

The demand for screws will be : [360.0, 208.0, 1120.0, 112.0, 792.0, 1160.0, 192.0, 960.0, 232.0, 1160.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]

class data_generator_MRP_screws():

  def __init__(self):

    self.demands = [[360, 208, 1120, 112, 792, 1160, 192, 960, 232, 1160, 0, 0, 0, 0, 0, 0]]
    self.days = range(len(self.demands[0]))

    self.production_rate = [1]* len(self.days)
    self.parts = [[0],
                  [0],
                  [0],
                  [0]]
    self.lead_time = [1]

    self.first_inventory = [50]
    self.production_cost = [100] * len(self.demands)

    self.inventory_cost = [5] * len(self.demands)
    self.setup_cost = [200] * len(self.demands)

start_time = time.time()
data = data_generator_MRP_screws()
PRODUCTION_PLAN, obj = opt_production_plan(data)
end_time = time.time()

run_time = end_time - start_time
for product in range(len(data.demands)):
    # print(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]))
  display(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]).round(0))
print('objective is : ', round(obj), '. Run time is : ', run_time)

2024-06-14 01:08:18,124 - DEBUG - Solver created.
2024-06-14 01:08:18,124 - DEBUG - Variables created.
2024-06-14 01:08:18,130 - DEBUG - Objective function added.
2024-06-14 01:08:18,134 - DEBUG - All constraints added.
2024-06-14 01:08:18,136 - DEBUG - Objective function set to minimize.
2024-06-14 01:08:18,140 - DEBUG - Solving the model, solver status: 2
2024-06-14 01:08:18,142 - DEBUG - Solver found the problem to be infeasible.

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[46], line 23
     21 start_time = time.time()
     22 data = data_generator_MRP_screws()
---> 23 PRODUCTION_PLAN, obj = opt_production_plan(data)
     24 end_time = time.time()
     26 run_time = end_time - start_time

TypeError: cannot unpack non-iterable NoneType object

# demand for screws for each table_top, legs and beams
list1 = [13.0, 0.0, 28.0, 0.0, 14.0, 29.0, 0.0, 24.0, 0.0, 29.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
list2 = [32.0, 0.0, 112.0, 0.0, 56.0, 116.0, 0.0, 96.0, 0.0, 116.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
list3 = [0.0, 52.0, 0.0, 28.0, 58.0, 0.0, 48.0, 0.0, 58.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]

# Multiply each list by the specified factor
list1_multiplied = [num * 1 for num in list1]
list2_multiplied = [num * 4 for num in list2]
list3_multiplied = [num * 2 for num in list3]

# Combine the three lists by adding corresponding elements
combined_list = [a + b + c for a, b, c in zip(list1_multiplied, list2_multiplied, list3_multiplied)]
print(f'The demand for planks will be : {combined_list}')

The demand for planks will be : [141.0, 104.0, 476.0, 56.0, 354.0, 493.0, 96.0, 408.0, 116.0, 493.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]

class data_generator_MRP_planks():

  def __init__(self):

    self.demands = [[141, 104, 476, 56, 354, 493, 96, 408, 116, 493, 0, 0, 0, 0, 0, 0]]
    self.days = range(len(self.demands[0]))

    self.production_rate = [1]* len(self.days)
    self.parts = [[0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0]]
    self.lead_time = [1]

    self.first_inventory = [100]
    self.production_cost = [100] * len(self.demands)

    self.inventory_cost = [5] * len(self.demands)
    self.setup_cost = [200] * len(self.demands)

start_time = time.time()
data = data_generator_MRP_planks()
PRODUCTION_PLAN, obj = opt_production_plan(data)
end_time = time.time()

run_time = end_time - start_time
for product in range(len(data.demands)):
    # print(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]))
  display(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]).round(0))
print('objective is : ', round(obj), '. Run time is : ', run_time)

2024-06-14 01:08:22,746 - DEBUG - Solver created.
2024-06-14 01:08:22,749 - DEBUG - Variables created.
2024-06-14 01:08:22,751 - DEBUG - Objective function added.
2024-06-14 01:08:22,756 - DEBUG - All constraints added.
2024-06-14 01:08:22,757 - DEBUG - Objective function set to minimize.
2024-06-14 01:08:22,759 - DEBUG - Solving the model, solver status: 2
2024-06-14 01:08:22,761 - DEBUG - Solver found the problem to be infeasible.

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[47], line 27
     25 start_time = time.time()
     26 data = data_generator_MRP_planks()
---> 27 PRODUCTION_PLAN, obj = opt_production_plan(data)
     28 end_time = time.time()
     30 run_time = end_time - start_time

TypeError: cannot unpack non-iterable NoneType object

# demand for screws for each table_top, legs and beams
list1 = [13.0, 0.0, 28.0, 0.0, 14.0, 29.0, 0.0, 24.0, 0.0, 29.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
list2 = [32.0, 0.0, 112.0, 0.0, 56.0, 116.0, 0.0, 96.0, 0.0, 116.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
list3 = [0.0, 52.0, 0.0, 28.0, 58.0, 0.0, 48.0, 0.0, 58.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]

# Multiply each list by the specified factor
list1_multiplied = [num * 4 for num in list1]
list2_multiplied = [num * 4 for num in list2]
list3_multiplied = [num * 4 for num in list3]

# Combine the three lists by adding corresponding elements
combined_list = [a + b + c for a, b, c in zip(list1_multiplied, list2_multiplied, list3_multiplied)]
print(f'The demand for brackets will be : {combined_list}')

The demand for brackets will be : [180.0, 208.0, 560.0, 112.0, 512.0, 580.0, 192.0, 480.0, 232.0, 580.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]

class data_generator_MRP_brackets():

  def __init__(self):

    self.demands = [[180, 208, 560, 112, 512, 580, 192, 480, 232, 580, 0, 0, 0, 0, 0, 0]]
    self.days = range(len(self.demands[0]))

    self.production_rate = [1]* len(self.days)
    self.parts = [[0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0]]
    self.lead_time = [1]

    self.first_inventory = [50]
    self.production_cost = [100] * len(self.demands)

    self.inventory_cost = [5] * len(self.demands)
    self.setup_cost = [200] * len(self.demands)

start_time = time.time()
data = data_generator_MRP_planks()
PRODUCTION_PLAN, obj = opt_production_plan(data)
end_time = time.time()

run_time = end_time - start_time
for product in range(len(data.demands)):
    # print(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]))
  display(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]).round(0))
print('objective is : ', round(obj), '. Run time is : ', run_time)

2024-06-14 01:08:28,260 - DEBUG - Solver created.
2024-06-14 01:08:28,261 - DEBUG - Variables created.
2024-06-14 01:08:28,262 - DEBUG - Objective function added.
2024-06-14 01:08:28,265 - DEBUG - All constraints added.
2024-06-14 01:08:28,265 - DEBUG - Objective function set to minimize.
2024-06-14 01:08:28,265 - DEBUG - Solving the model, solver status: 2
2024-06-14 01:08:28,265 - DEBUG - Solver found the problem to be infeasible.

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[49], line 27
     25 start_time = time.time()
     26 data = data_generator_MRP_planks()
---> 27 PRODUCTION_PLAN, obj = opt_production_plan(data)
     28 end_time = time.time()
     30 run_time = end_time - start_time

TypeError: cannot unpack non-iterable NoneType object

# demand for glue for each leg, plank and beams
list1 = [141.0, 104.0, 476.0, 56.0, 354.0, 493.0, 96.0, 408.0, 116.0, 493.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
list2 = [32.0, 0.0, 112.0, 0.0, 56.0, 116.0, 0.0, 96.0, 0.0, 116.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
list3 = [0.0, 52.0, 0.0, 28.0, 58.0, 0.0, 48.0, 0.0, 58.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]

# Multiply each list by the specified factor
list1_multiplied = [num * 1 for num in list1]
list2_multiplied = [num * 1 for num in list2]
list3_multiplied = [num * 1 for num in list3]

# Combine the three lists by adding corresponding elements
combined_list = [a + b + c for a, b, c in zip(list1_multiplied, list2_multiplied, list3_multiplied)]
print(f'The demand for glue will be : {combined_list}')

The demand for glue will be : [173.0, 156.0, 588.0, 84.0, 468.0, 609.0, 144.0, 504.0, 174.0, 609.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]

class data_generator_MRP_planks():

  def __init__(self):

    self.demands = [[173.0, 156.0, 588.0, 84.0, 468.0, 609.0, 144.0, 504.0, 174.0, 609.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]
    self.days = range(len(self.demands[0]))

    self.production_rate = [1]* len(self.days)
    self.parts = [[0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0]]
    self.lead_time = [1]

    self.first_inventory = [100]
    self.production_cost = [100] * len(self.demands)

    self.inventory_cost = [5] * len(self.demands)
    self.setup_cost = [200] * len(self.demands)

start_time = time.time()
data = data_generator_MRP_planks()
PRODUCTION_PLAN, obj = opt_production_plan(data)
end_time = time.time()

run_time = end_time - start_time
for product in range(len(data.demands)):
    # print(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]))
  display(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]).round(0))
print('objective is : ', round(obj), '. Run time is : ', run_time)

2024-06-14 01:08:33,028 - DEBUG - Solver created.
2024-06-14 01:08:33,029 - DEBUG - Variables created.
2024-06-14 01:08:33,030 - DEBUG - Objective function added.
2024-06-14 01:08:33,032 - DEBUG - All constraints added.
2024-06-14 01:08:33,033 - DEBUG - Objective function set to minimize.
2024-06-14 01:08:33,035 - DEBUG - Solving the model, solver status: 2
2024-06-14 01:08:33,035 - DEBUG - Solver found the problem to be infeasible.

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[51], line 27
     25 start_time = time.time()
     26 data = data_generator_MRP_planks()
---> 27 PRODUCTION_PLAN, obj = opt_production_plan(data)
     28 end_time = time.time()
     30 run_time = end_time - start_time

TypeError: cannot unpack non-iterable NoneType object

start_time = time.time()
data = ProjectData()

data.demands = [
            [0, 0, 0, 0, 0, 18, 15, 16, 12, 14, 19, 10, 13, 11, 17, 12],  # Table demand
            [0]*16,  # Tabletop demand
            [0]*16,  # Leg demand
            [0, 0, 0, 0, 0, 5, 7, 4, 6, 7, 3, 6, 5, 4, 7, 6],  # Beam demand 
            [0]*16,  # Screw demand
            [0]*16,  # Plank demand
            [0]*16,  # Bracket demand
            [0]*16   # Glue demand
        ]
PRODUCTION_PLAN, obj = opt_production_plan(data)
end_time = time.time()

run_time = end_time - start_time
for product in range(len(data.demands)):
    # print(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]))
  display(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]).round(0))
print('objective is : ', round(obj), '. Run time is : ', run_time)

2024-06-14 01:08:38,466 - DEBUG - Solver created.
2024-06-14 01:08:38,468 - DEBUG - Variables created.
2024-06-14 01:08:38,472 - DEBUG - Objective function added.
2024-06-14 01:08:38,480 - DEBUG - All constraints added.
2024-06-14 01:08:38,480 - DEBUG - Objective function set to minimize.
2024-06-14 01:08:48,500 - DEBUG - Solving the model, solver status: 0
2024-06-14 01:08:48,500 - DEBUG - Optimal solution found.

objective is :  1785186 . Run time is :  10.0503990650177

start_time = time.time()
data = ProjectData()
data.production_cost = [100, 30, 40, 70, 40, 60, 80, 30]
PRODUCTION_PLAN, obj = opt_production_plan(data)
end_time = time.time()

run_time = end_time - start_time
for product in range(len(data.demands)):
    # print(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]))
  display(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]).round(0))
print('objective is : ', round(obj), '. Run time is : ', run_time)

2024-06-14 01:08:48,671 - DEBUG - Solver created.
2024-06-14 01:08:48,674 - DEBUG - Variables created.
2024-06-14 01:08:48,689 - DEBUG - Objective function added.
2024-06-14 01:08:48,716 - DEBUG - All constraints added.
2024-06-14 01:08:48,718 - DEBUG - Objective function set to minimize.
2024-06-14 01:08:54,918 - DEBUG - Solving the model, solver status: 0
2024-06-14 01:08:54,920 - DEBUG - Optimal solution found.

objective is :  867616 . Run time is :  6.265593528747559

def opt_production_plan_2(data):
  logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
  # Create the mip solver with the SCIP backend.
  m = pywraplp.Solver.CreateSolver('SCIP')
  logging.debug("Solver created.")
  # decision variables
  obj = m.NumVar(0, 1000000000, 'obj')

  setup = []
  production = []
  inventory = []
  for product in range(len(data.demands)):
    setup_temp = []
    production_temp = []
    inventory_temp = []
    for day in range(len(data.days)):
        suffix = '_{}_{}'.format(product, day)
        setup_temp.append(m.BoolVar('setup' + suffix))
        production_temp.append(m.NumVar(0, 100000, 'production' + suffix))
        inventory_temp.append(m.NumVar(0, 100000, 'inventory' + suffix))

    setup.append(setup_temp)
    production.append(production_temp)
    inventory.append(inventory_temp)
  logging.debug("Variables created.")


  # Objective function setup
  objective_terms = []
  for product in range(len(data.demands)):
      for day in range(len(data.days)):
          term = production[product][day] * data.production_cost[product][day] \
              + setup[product][day] * data.setup_cost[product] \
              + inventory[product][day] * data.inventory_cost[product]
          objective_terms.append(term)

  m.Add(obj >= sum(objective_terms))

  logging.debug("Objective function added.")
  # Demand constraint
  for product in range(len(data.demands)):
    for day in data.days:
      # Setup constraint
      #logging.debug(f"Adding setup constraint for product {product}, day {day}.")
      m.Add(production[product][day] <= 100000 * setup[product][day])
      #logging.debug(f"Setup constraint for product {product}, day {day} added.")

      if day != 0:
        if day - data.lead_time[product] >= 0:
            m.Add(inventory[product][day-1] + production[product][day - data.lead_time[product]] == \
                  (data.demands[product][day] + sum(data.parts[unit][product] * production[unit][day] for unit in range(len(data.demands)))) + inventory[product][day])
        else:
          m.Add(inventory[product][day-1] == (data.demands[product][day] + sum(data.parts[unit][product] * production[unit][day] for unit in range(len(data.demands)))) + inventory[product][day])
      else:
        m.Add(data.first_inventory[product] == (data.demands[product][0] + sum(data.parts[unit][product] * production[unit][0] for unit in range(len(data.demands)))) + inventory[product][0])
      #logging.debug(f"Demand balance constraint for product {product}, day {day} added.")

  logging.debug("All constraints added.")

  # objective function
  m.Minimize(obj)
  logging.debug("Objective function set to minimize.")
  # solving the model
  status = m.Solve()
  logging.debug(f"Solving the model, solver status: {status}")
  if status == pywraplp.Solver.OPTIMAL:

      PRODUCTION_PLAN = {}
      for product in range(len(data.demands)):
        PRODUCTION_PLAN_temp = {}
        for m_idx, day in enumerate(data.days):
            PRODUCTION_PLAN_temp[day] = {
                'product ' + str(product):   production[product][m_idx].solution_value(), \
                'setup':                     setup[product][m_idx].solution_value(), \
                'inventory':                 inventory[product][m_idx].solution_value()
                }
        PRODUCTION_PLAN[product] = PRODUCTION_PLAN_temp
      logging.debug("Optimal solution found.")
      return PRODUCTION_PLAN, obj.solution_value()

  elif status == pywraplp.Solver.FEASIBLE:
      logging.debug("Solver found a feasible solution, not necessarily optimal.")
  elif status == pywraplp.Solver.INFEASIBLE:
      logging.debug("Solver found the problem to be infeasible.")
  elif status == pywraplp.Solver.UNBOUNDED:
      logging.debug("Solver found the problem to be unbounded.")
  else:
      logging.debug("Solver ended with an unknown status.")

start_time = time.time()
data = ProjectData()

data.production_cost = [
        [100] * 16,
        [30] * 16,
        [40] * 16,
        [70] * 16,
        [40] * 16,
        [60] * 16,
        [80] * 16,
        [30] * 16
    ]
# Updating production costs for high-demand periods
high_demand_start, high_demand_end = 4, 9  # Days 5 to 9 (0-indexed as 4 to 8)
affected_items = [0, 1, 2, 3]  # Table, Tabletop, Leg, Beams
print("Production costs before update:", data.production_cost)
for day in range(high_demand_start, high_demand_end):
    for item in affected_items:
        data.production_cost[item][day] *= 2
print("Production costs after update:", data.production_cost)


PRODUCTION_PLAN, obj = opt_production_plan_2(data)
end_time = time.time()

run_time = end_time - start_time
for product in range(len(data.demands)):
    # print(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]))
  display(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]).round(0))
print('objective is : ', round(obj), '. Run time is : ', run_time)

2024-06-14 01:08:55,046 - DEBUG - Solver created.
2024-06-14 01:08:55,047 - DEBUG - Variables created.
2024-06-14 01:08:55,047 - DEBUG - Objective function added.

2024-06-14 01:08:55,057 - DEBUG - All constraints added.
2024-06-14 01:08:55,057 - DEBUG - Objective function set to minimize.

Production costs before update: [[100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100], [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30], [40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40], [70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70], [40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40], [60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60], [80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80], [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30]]
Production costs after update: [[100, 100, 100, 100, 200, 200, 200, 200, 200, 100, 100, 100, 100, 100, 100, 100], [30, 30, 30, 30, 60, 60, 60, 60, 60, 30, 30, 30, 30, 30, 30, 30], [40, 40, 40, 40, 80, 80, 80, 80, 80, 40, 40, 40, 40, 40, 40, 40], [70, 70, 70, 70, 140, 140, 140, 140, 140, 70, 70, 70, 70, 70, 70, 70], [40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40], [60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60], [80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80], [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30]]

2024-06-14 01:08:55,407 - DEBUG - Solving the model, solver status: 0
2024-06-14 01:08:55,409 - DEBUG - Optimal solution found.

objective is :  879819 . Run time is :  0.3698713779449463

def opt_production_plan_3(data):
  logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
  # Create the mip solver with the SCIP backend.
  m = pywraplp.Solver.CreateSolver('SCIP')
  logging.debug("Solver created.")
  # decision variables
  obj = m.NumVar(0, 1000000000, 'obj')

  setup = []
  production = []
  inventory = []
  for product in range(len(data.demands)):
    setup_temp = []
    production_temp = []
    inventory_temp = []
    for day in range(len(data.days)):
        suffix = '_{}_{}'.format(product, day)
        setup_temp.append(m.BoolVar('setup' + suffix))
        production_temp.append(m.NumVar(0, 100000, 'production' + suffix))
        inventory_temp.append(m.NumVar(0, 100000, 'inventory' + suffix))

    setup.append(setup_temp)
    production.append(production_temp)
    inventory.append(inventory_temp)
  logging.debug("Variables created.")


  # Objective function setup
  objective_terms = []
  for product in range(len(data.demands)):
      for day in range(len(data.days)):
          term = production[product][day] * data.production_cost[product][day] \
              + setup[product][day] * data.setup_cost[product] \
              + inventory[product][day] * data.inventory_cost[product][day]
          objective_terms.append(term)

  m.Add(obj >= sum(objective_terms))

  logging.debug("Objective function added.")
  # Demand constraint
  for product in range(len(data.demands)):
    for day in data.days:
      # Setup constraint
      #logging.debug(f"Adding setup constraint for product {product}, day {day}.")
      m.Add(production[product][day] <= 100000 * setup[product][day])
      #logging.debug(f"Setup constraint for product {product}, day {day} added.")

      if day != 0:
        if day - data.lead_time[product] >= 0:
            m.Add(inventory[product][day-1] + production[product][day - data.lead_time[product]] == \
                  (data.demands[product][day] + sum(data.parts[unit][product] * production[unit][day] for unit in range(len(data.demands)))) + inventory[product][day])
        else:
          m.Add(inventory[product][day-1] == (data.demands[product][day] + sum(data.parts[unit][product] * production[unit][day] for unit in range(len(data.demands)))) + inventory[product][day])
      else:
        m.Add(data.first_inventory[product] == (data.demands[product][0] + sum(data.parts[unit][product] * production[unit][0] for unit in range(len(data.demands)))) + inventory[product][0])
      #logging.debug(f"Demand balance constraint for product {product}, day {day} added.")

  logging.debug("All constraints added.")

  # objective function
  m.Minimize(obj)
  logging.debug("Objective function set to minimize.")
  # solving the model
  status = m.Solve()
  logging.debug(f"Solving the model, solver status: {status}")
  if status == pywraplp.Solver.OPTIMAL:

      PRODUCTION_PLAN = {}
      for product in range(len(data.demands)):
        PRODUCTION_PLAN_temp = {}
        for m_idx, day in enumerate(data.days):
            PRODUCTION_PLAN_temp[day] = {
                'product ' + str(product):   production[product][m_idx].solution_value(), \
                'setup':                     setup[product][m_idx].solution_value(), \
                'inventory':                 inventory[product][m_idx].solution_value()
                }
        PRODUCTION_PLAN[product] = PRODUCTION_PLAN_temp
      logging.debug("Optimal solution found.")
      return PRODUCTION_PLAN, obj.solution_value()

  elif status == pywraplp.Solver.FEASIBLE:
      logging.debug("Solver found a feasible solution, not necessarily optimal.")
  elif status == pywraplp.Solver.INFEASIBLE:
      logging.debug("Solver found the problem to be infeasible.")
  elif status == pywraplp.Solver.UNBOUNDED:
      logging.debug("Solver found the problem to be unbounded.")
  else:
      logging.debug("Solver ended with an unknown status.")

class ProjectData:

  def __init__(self):

    self.demands = [
            [0, 0, 0, 0, 0, 18, 15, 16, 12, 14, 19, 10, 13, 11, 17, 12],  # Table demand
            [0]*16,  # Tabletop demand
            [0]*16,  # Leg demand
            [0, 0, 0, 0, 0, 5, 7, 4, 6, 7, 3, 6, 5, 4, 7, 6],  # Beam demand 
            [0]*16,  # Screw demand
            [0]*16,  # Plank demand
            [0]*16,  # Bracket demand
            [0]*16   # Glue demand
        ]

    self.days = range(len(self.demands[0]))

    self.parts = [
            [0, 1, 4, 2, 0, 0, 0, 0],  # Table
            [0, 0, 0, 0, 8, 1, 4, 0],  # Tabletop
            [0, 0, 0, 0, 8, 4, 4, 1],  # Leg
            [0, 0, 0, 0, 4, 2, 4, 1],  # Beam
            [0, 0, 0, 0, 0, 0, 0, 0],  # Screws
            [0, 0, 0, 0, 0, 0, 0, 1],  # Plank
            [0, 0, 0, 0, 0, 0, 0, 0],  # Brackets
            [0, 0, 0, 0, 0, 0, 0, 0]   # Glue
        ]

    self.lead_time = [3, 2, 2, 3, 1, 1, 1, 1]

    self.production_cost = [
            [100] * 16,
            [30] * 16,
            [40] * 16,
            [70] * 16,
            [40] * 16,
            [60] * 16,
            [80] * 16,
            [30] * 16
        ]
    # Updating production costs for high-demand periods
    high_demand_start, high_demand_end = 4, 9  # Days 5 to 9 (0-indexed as 4 to 8)
    affected_items = [0, 1, 2, 3]  # Table, Tabletop, Leg, Beams
    print("Production costs before update:", self.production_cost)
    for day in range(high_demand_start, high_demand_end):
        for item in affected_items:
            self.production_cost[item][day] *= 2
    print("Production costs after update:", self.production_cost)
            
    self.first_inventory = [0, 20, 100, 70, 50, 100, 50, 100]
    # Initialize inventory costs with last 5 days adjusted for the table
    self.inventory_cost = [
        [20] * 16,
        [10] * 16,
        [10] * 16,
        [10] * 16,
        [5] * 16,
        [5] * 16,
        [5] * 16,
        [5] * 16
    ]
    print(self.inventory_cost)
    for day in range(11, 16):  # Days 12 to 16 (0-indexed as 11 to 15)
      self.inventory_cost[0][day] = 100  # Correctly accessing the first product's cost array

    print(self.inventory_cost)
    self.setup_cost = [500, 200, 200, 200, 200, 200, 200, 200]
    
start_time = time.time()
data = ProjectData()
PRODUCTION_PLAN, obj = opt_production_plan_3(data)
end_time = time.time()

run_time = end_time - start_time
for product in range(len(data.demands)):
    # print(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]))
  display(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]).round(0))
print('objective is : ', round(obj), '. Run time is : ', run_time)

2024-06-14 01:08:55,556 - DEBUG - Solver created.
2024-06-14 01:08:55,558 - DEBUG - Variables created.
2024-06-14 01:08:55,561 - DEBUG - Objective function added.
2024-06-14 01:08:55,575 - DEBUG - All constraints added.
2024-06-14 01:08:55,602 - DEBUG - Objective function set to minimize.

Production costs before update: [[100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100], [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30], [40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40], [70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70], [40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40], [60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60], [80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80], [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30]]
Production costs after update: [[100, 100, 100, 100, 200, 200, 200, 200, 200, 100, 100, 100, 100, 100, 100, 100], [30, 30, 30, 30, 60, 60, 60, 60, 60, 30, 30, 30, 30, 30, 30, 30], [40, 40, 40, 40, 80, 80, 80, 80, 80, 40, 40, 40, 40, 40, 40, 40], [70, 70, 70, 70, 140, 140, 140, 140, 140, 70, 70, 70, 70, 70, 70, 70], [40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40], [60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60], [80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80], [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30]]
[[20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]]
[[20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 100, 100, 100, 100, 100], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]]

2024-06-14 01:08:56,090 - DEBUG - Solving the model, solver status: 0
2024-06-14 01:08:56,091 - DEBUG - Optimal solution found.

objective is :  929369 . Run time is :  0.5447497367858887

class ProjectData:

  def __init__(self):

    self.demands = [
            [0, 0, 0, 0, 0, 18, 15, 16, 12, 14, 19, 10, 13, 11, 17, 12],  # Table demand
            [0]*16,  # Tabletop demand
            [0]*16,  # Leg demand
            [0, 0, 0, 0, 0, 5, 7, 4, 6, 7, 3, 6, 5, 4, 7, 6],  # Beam demand 
            [0]*16,  # Screw demand
            [0]*16,  # Plank demand
            [0]*16,  # Bracket demand
            [0]*16   # Glue demand
        ]

    self.days = range(len(self.demands[0]))

    self.parts = [
            [0, 1, 4, 2, 0, 0, 0, 0],  # Table
            [0, 0, 0, 0, 8, 1, 4, 0],  # Tabletop
            [0, 0, 0, 0, 8, 4, 4, 1],  # Leg
            [0, 0, 0, 0, 4, 2, 4, 1],  # Beam
            [0, 0, 0, 0, 0, 0, 0, 0],  # Screws
            [0, 0, 0, 0, 0, 0, 0, 1],  # Plank
            [0, 0, 0, 0, 0, 0, 0, 0],  # Brackets
            [0, 0, 0, 0, 0, 0, 0, 0]   # Glue
        ]

    self.lead_time = [3, 2, 2, 3, 1, 1, 1, 1]

    self.production_cost = [
            [100] * 16,
            [30] * 16,
            [40] * 16,
            [70] * 16,
            [40] * 16,
            [60] * 16,
            [80] * 16,
            [30] * 16
        ]
    # Updating production costs for high-demand periods
    high_demand_start, high_demand_end = 4, 9  # Days 5 to 9 (0-indexed as 4 to 8)
    affected_items = [0, 1, 2, 3]  # Table, Tabletop, Leg, Beams
    print("Production costs before update:", self.production_cost)
    for day in range(high_demand_start, high_demand_end):
        for item in affected_items:
            self.production_cost[item][day] *= 2
    print("Production costs after update:", self.production_cost)
            
    self.first_inventory = [0, 20, 100, 70, 50, 100, 50, 100]
    # Initialize inventory costs with last 5 days adjusted for the table
    self.inventory_cost = [
        [20] * 16,
        [10] * 16,
        [10] * 16,
        [10] * 16,
        [5] * 16,
        [5] * 16,
        [5] * 16,
        [5] * 16
    ]
    print(self.inventory_cost)
    for day in range(11, 16):  # Days 12 to 16 (0-indexed as 11 to 15)
      self.inventory_cost[0][day] = 100  # Correctly accessing the first product's cost array

    self.setup_cost = [10000, 200, 200, 200, 200, 200, 200, 200]

start_time = time.time()
data = ProjectData()
PRODUCTION_PLAN, obj = opt_production_plan_3(data)
end_time = time.time()

run_time = end_time - start_time
for product in range(len(data.demands)):
    # print(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]))
  display(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]).round(0))
print('objective is : ', round(obj), '. Run time is : ', run_time)

2024-06-14 01:09:01,044 - DEBUG - Solver created.
2024-06-14 01:09:01,046 - DEBUG - Variables created.
2024-06-14 01:09:01,049 - DEBUG - Objective function added.
2024-06-14 01:09:01,058 - DEBUG - All constraints added.
2024-06-14 01:09:01,059 - DEBUG - Objective function set to minimize.

Production costs before update: [[100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100], [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30], [40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40], [70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70], [40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40], [60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60], [80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80], [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30]]
Production costs after update: [[100, 100, 100, 100, 200, 200, 200, 200, 200, 100, 100, 100, 100, 100, 100, 100], [30, 30, 30, 30, 60, 60, 60, 60, 60, 30, 30, 30, 30, 30, 30, 30], [40, 40, 40, 40, 80, 80, 80, 80, 80, 40, 40, 40, 40, 40, 40, 40], [70, 70, 70, 70, 140, 140, 140, 140, 140, 70, 70, 70, 70, 70, 70, 70], [40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40], [60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60], [80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80], [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30]]
[[20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]]

2024-06-14 01:09:01,596 - DEBUG - Solving the model, solver status: 0
2024-06-14 01:09:01,596 - DEBUG - Optimal solution found.

objective is :  978119 . Run time is :  0.5649333000183105

data = ProjectData()
for i in range(500,10000, 500):
  start_time = time.time()
  print(f'testing setup cost of : {i}')
  data.setup_cost[0] = i
  PRODUCTION_PLAN, obj = opt_production_plan_3(data)
  end_time = time.time()
  run_time = end_time - start_time
  for product in range(len(data.demands)):
      # print(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]))
    display(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]).round(0))
  print('objective is : ', round(obj), '. Run time is : ', run_time)

2024-06-14 01:09:06,495 - DEBUG - Solver created.
2024-06-14 01:09:06,497 - DEBUG - Variables created.
2024-06-14 01:09:06,498 - DEBUG - Objective function added.
2024-06-14 01:09:06,509 - DEBUG - All constraints added.
2024-06-14 01:09:06,510 - DEBUG - Objective function set to minimize.

Production costs before update: [[100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100], [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30], [40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40], [70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70], [40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40], [60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60], [80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80], [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30]]
Production costs after update: [[100, 100, 100, 100, 200, 200, 200, 200, 200, 100, 100, 100, 100, 100, 100, 100], [30, 30, 30, 30, 60, 60, 60, 60, 60, 30, 30, 30, 30, 30, 30, 30], [40, 40, 40, 40, 80, 80, 80, 80, 80, 40, 40, 40, 40, 40, 40, 40], [70, 70, 70, 70, 140, 140, 140, 140, 140, 70, 70, 70, 70, 70, 70, 70], [40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40], [60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60], [80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80], [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30]]
[[20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]]
testing setup cost of : 500

2024-06-14 01:09:06,946 - DEBUG - Solving the model, solver status: 0
2024-06-14 01:09:06,946 - DEBUG - Optimal solution found.

2024-06-14 01:09:07,060 - DEBUG - Solver created.
2024-06-14 01:09:07,061 - DEBUG - Variables created.
2024-06-14 01:09:07,064 - DEBUG - Objective function added.
2024-06-14 01:09:07,072 - DEBUG - All constraints added.
2024-06-14 01:09:07,073 - DEBUG - Objective function set to minimize.

objective is :  929369 . Run time is :  0.4676969051361084
testing setup cost of : 1000

2024-06-14 01:09:07,439 - DEBUG - Solving the model, solver status: 0
2024-06-14 01:09:07,446 - DEBUG - Optimal solution found.

2024-06-14 01:09:07,543 - DEBUG - Solver created.
2024-06-14 01:09:07,544 - DEBUG - Variables created.
2024-06-14 01:09:07,546 - DEBUG - Objective function added.
2024-06-14 01:09:07,554 - DEBUG - All constraints added.
2024-06-14 01:09:07,555 - DEBUG - Objective function set to minimize.

objective is :  932369 . Run time is :  0.3900461196899414
testing setup cost of : 1500

2024-06-14 01:09:08,005 - DEBUG - Solving the model, solver status: 0
2024-06-14 01:09:08,005 - DEBUG - Optimal solution found.

2024-06-14 01:09:08,104 - DEBUG - Solver created.
2024-06-14 01:09:08,104 - DEBUG - Variables created.
2024-06-14 01:09:08,112 - DEBUG - Objective function added.
2024-06-14 01:09:08,121 - DEBUG - All constraints added.
2024-06-14 01:09:08,122 - DEBUG - Objective function set to minimize.

class ProjectData:

  def __init__(self):

    self.demands = [
            [0, 0, 0, 0, 0, 18, 15, 16, 12, 14, 19, 10, 13, 11, 17, 12],  # Table demand
            [0]*16,  # Tabletop demand
            [0]*16,  # Leg demand
            [0, 0, 0, 0, 0, 5, 7, 4, 6, 7, 3, 6, 5, 4, 7, 6],  # Beam demand
            [0]*16,  # Screw demand
            [0]*16,  # Plank demand
            [0]*16,  # Bracket demand
            [0]*16   # Glue demand
        ]

    self.days = range(len(self.demands[0]))

    self.parts = [
            [0, 1, 4, 2, 0, 0, 0, 0],  # Table
            [0, 0, 0, 0, 8, 1, 4, 0],  # Tabletop
            [0, 0, 0, 0, 8, 4, 4, 1],  # Leg
            [0, 0, 0, 0, 4, 2, 4, 1],  # Beam
            [0, 0, 0, 0, 0, 0, 0, 0],  # Screws
            [0, 0, 0, 0, 0, 0, 0, 1],  # Plank
            [0, 0, 0, 0, 0, 0, 0, 0],  # Brackets
            [0, 0, 0, 0, 0, 0, 0, 0]   # Glue
        ]

    self.lead_time = [3, 2, 2, 3, 1, 1, 1, 1]

    self.production_cost = [
            [100] * 16,
            [30] * 16,
            [40] * 16,
            [70] * 16,
            [40] * 16,
            [60] * 16,
            [80] * 16,
            [30] * 16
        ]
    # Updating production costs for high-demand periods
    high_demand_start, high_demand_end = 4, 9  # Days 5 to 9 (0-indexed as 4 to 8)
    affected_items = [0, 1, 2, 3]  # Table, Tabletop, Leg, Beams
    print("Production costs before update:", self.production_cost)
    for day in range(high_demand_start, high_demand_end):
        for item in affected_items:
            self.production_cost[item][day] *= 2
    print("Production costs after update:", self.production_cost)

    self.first_inventory = [0, 20, 100, 70, 50, 100, 50, 100]
    # Initialize inventory costs with last 5 days adjusted for the table
    self.inventory_cost = [
        [20] * 16,
        [10] * 16,
        [10] * 16,
        [10] * 16,
        [5] * 16,
        [5] * 16,
        [5] * 16,
        [5] * 16
    ]
    print(self.inventory_cost)
    for day in range(11, 16):  # Days 12 to 16 (0-indexed as 11 to 15)
      self.inventory_cost[0][day] = 100  # Correctly accessing the first product's cost array

    print(self.inventory_cost)
    self.setup_cost = [500, 200, 200, 200, 200, 200, 200, 200]

    capacity = [6.4 * 60 * 4, 6 * 60 * 2, 7.2 * 60, 7.6 * 60, 7.6 * 60, 7.84 * 60]

    self.capacity = [[element] * len(self.days) for element in capacity]

    self.production_rate = [[0, 0, 0, 3, 1.5, 2],  # Table
                            [0, 1.5, 0.9, 0, 0, 0],  # Tabletop
                            [0, 1.5, 0.9, 0, 0, 0],  # Leg
                            [0, 1.5, 0.9, 0, 0, 0],  # Beam
                            [0, 0, 0, 0, 0, 0],  # Screws
                            [1, 0, 0, 0, 0, 0],  # Plank
                            [0, 0, 0, 0, 0, 0],  # Brackets
                            [0, 0, 0, 0, 0, 0]]  # Glue

    self.setup_time = [[0, 0, 0, 0, 0, 0],  # Table
                       [0, 30, 5, 0, 0, 0],  # Tabletop
                       [0, 30, 5, 0, 0, 0],  # Leg
                       [0, 30, 5, 0, 0, 0],  # Beam
                       [0, 0, 0, 0, 0, 0],  # Screws
                       [0, 0, 0, 0, 0, 0],  # Plank
                       [0, 0, 0, 0, 0, 0],  # Brackets
                       [0, 0, 0, 0, 0, 0]]  # Glue

    self.machines = range(len(self.production_rate[0]))
start_time = time.time()
data = ProjectData()
PRODUCTION_PLAN, obj = opt_production_plan_3(data)
end_time = time.time()

run_time = end_time - start_time
for product in range(len(data.demands)):
    # print(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]))
  display(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]).round(0))
print('objective is : ', round(obj), '. Run time is : ', run_time)

2024-06-14 01:09:36,104 - DEBUG - Solver created.
2024-06-14 01:09:36,106 - DEBUG - Variables created.
2024-06-14 01:09:36,108 - DEBUG - Objective function added.

2024-06-14 01:09:36,114 - DEBUG - All constraints added.
2024-06-14 01:09:36,114 - DEBUG - Objective function set to minimize.

Production costs before update: [[100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100], [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30], [40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40], [70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70], [40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40], [60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60], [80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80], [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30]]
Production costs after update: [[100, 100, 100, 100, 200, 200, 200, 200, 200, 100, 100, 100, 100, 100, 100, 100], [30, 30, 30, 30, 60, 60, 60, 60, 60, 30, 30, 30, 30, 30, 30, 30], [40, 40, 40, 40, 80, 80, 80, 80, 80, 40, 40, 40, 40, 40, 40, 40], [70, 70, 70, 70, 140, 140, 140, 140, 140, 70, 70, 70, 70, 70, 70, 70], [40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40], [60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60], [80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80], [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30]]
[[20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]]
[[20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 100, 100, 100, 100, 100], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]]

2024-06-14 01:09:36,555 - DEBUG - Solving the model, solver status: 0
2024-06-14 01:09:36,557 - DEBUG - Optimal solution found.

objective is :  929369 . Run time is :  0.4680349826812744

class data_generator_MPS():

  def __init__(self):

    self.demands = [[0, 0, 0, 0, 0, 18, 15, 16, 12, 14, 19, 10, 13, 11, 17, 12]]

    self.days = range(len(self.demands[0]))

    self.parts = [[0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0]]

    self.lead_time = [3]


    self.production_cost = [[100, 100, 100, 100, 200, 200, 200, 200, 200, 100, 100, 100, 100, 100, 100, 100]]
    self.first_inventory = [0]
    self.inventory_cost = [[20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 100, 100, 100, 100, 100]]
    self.setup_cost = [500] * len(self.demands)

    capacity = [6.4 * 60 * 4, 6 * 60 * 2, 7.2 * 60, 7.6 * 60, 7.6 * 60, 7.84 * 60]
    self.capacity = [[element] * len(self.days) for element in capacity]

    self.production_rate = [[0, 0, 0, 3, 1.5, 2]]
    self.setup_time = [[0, 30, 5, 0, 0, 0]]

    self.machines = range(len(self.production_rate[0]))
    
start_time = time.time()
data = data_generator_MPS()
PRODUCTION_PLAN, obj = opt_production_plan_3(data)
end_time = time.time()

run_time = end_time - start_time
for product in range(len(data.demands)):
    # print(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]))
  display(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]).round(0))
print('objective is : ', round(obj), '. Run time is : ', run_time)

2024-06-14 01:10:02,759 - DEBUG - Solver created.
2024-06-14 01:10:02,759 - DEBUG - Variables created.
2024-06-14 01:10:02,773 - DEBUG - Objective function added.
2024-06-14 01:10:02,778 - DEBUG - All constraints added.
2024-06-14 01:10:02,780 - DEBUG - Objective function set to minimize.
2024-06-14 01:10:02,790 - DEBUG - Solving the model, solver status: 0

2024-06-14 01:10:02,792 - DEBUG - Optimal solution found.

objective is :  22860 . Run time is :  0.046892404556274414

class data_generator_MRP_tableT():

  def __init__(self):

    self.demands = [[0, 0, 18, 86, 0, 0, 0, 0, 0, 13, 11, 17, 12, 0, 0, 0]]

    self.days = range(len(self.demands[0]))

    self.parts = [[0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0]]

    self.lead_time = [2]


    self.production_cost = [[30, 30, 30, 30, 60, 60, 60, 60, 60, 30, 30, 30, 30, 30, 30, 30]]
    self.first_inventory = [20]
    self.inventory_cost = [[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]]
    self.setup_cost = [200] * len(self.demands)

    capacity = [6.4 * 60 * 4, 6 * 60 * 2, 7.2 * 60, 7.6 * 60, 7.6 * 60, 7.84 * 60]
    self.capacity = [[element] * len(self.days) for element in capacity]

    self.production_rate = [[0, 1.5, 0.9, 0, 0, 0]]
    self.setup_time = [[0, 30, 5, 0, 0, 0]]

    self.machines = range(len(self.production_rate[0]))

start_time = time.time()
data = data_generator_MRP_tableT()
PRODUCTION_PLAN, obj = opt_production_plan_3(data)
end_time = time.time()

run_time = end_time - start_time
for product in range(len(data.demands)):
  display(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]).round(0))
print('objective is : ', round(obj), '. Run time is : ', run_time)

2024-06-14 01:10:11,453 - DEBUG - Solver created.
2024-06-14 01:10:11,454 - DEBUG - Variables created.
2024-06-14 01:10:11,456 - DEBUG - Objective function added.
2024-06-14 01:10:11,457 - DEBUG - All constraints added.
2024-06-14 01:10:11,458 - DEBUG - Objective function set to minimize.
2024-06-14 01:10:11,463 - DEBUG - Solving the model, solver status: 0
2024-06-14 01:10:11,463 - DEBUG - Optimal solution found.

objective is :  6080 . Run time is :  0.018091440200805664

class data_generator_MRP_leg():

  def __init__(self):

    self.demands = [[0, 0, 18*4, 86*4, 0, 0, 0, 0, 0, 13*4, 11*4, 17*4, 12*4, 0, 0, 0]]

    self.days = range(len(self.demands[0]))

    self.parts = [[0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0]]

    self.lead_time = [2]


    self.production_cost = [[40, 40, 40, 40, 80, 80, 80, 80, 80, 40, 40, 40, 40, 40, 40, 40]]
    self.first_inventory = [100]
    self.inventory_cost = [[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]]
    self.setup_cost = [200] * len(self.demands)

    capacity = [6.4 * 60 * 4, 6 * 60 * 2, 7.2 * 60, 7.6 * 60, 7.6 * 60, 7.84 * 60]
    self.capacity = [[element] * len(self.days) for element in capacity]

    self.production_rate = [[0, 1.5, 0.9, 0, 0, 0]]
    self.setup_time = [[0, 30, 5, 0, 0, 0]]

    self.machines = range(len(self.production_rate[0]))

start_time = time.time()
data = data_generator_MRP_leg()
PRODUCTION_PLAN, obj = opt_production_plan_3(data)
end_time = time.time()

run_time = end_time - start_time
for product in range(len(data.demands)):
  display(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]).round(0))
print('objective is : ', round(obj), '. Run time is : ', run_time)

2024-06-14 01:15:41,346 - DEBUG - Solver created.
2024-06-14 01:15:41,346 - DEBUG - Variables created.
2024-06-14 01:15:41,350 - DEBUG - Objective function added.
2024-06-14 01:15:41,351 - DEBUG - All constraints added.
2024-06-14 01:15:41,355 - DEBUG - Objective function set to minimize.
2024-06-14 01:15:41,369 - DEBUG - Solving the model, solver status: 0
2024-06-14 01:15:41,372 - DEBUG - Optimal solution found.

objective is :  28240 . Run time is :  0.03952646255493164

class data_generator_MRP_beam():

  def __init__(self):

    self.demands = [[0, 0, 18*2, 86*2, 0, 0, 0, 0, 0, 13*2, 11*2, 17*2, 12*2, 0, 0, 0]]

    self.days = range(len(self.demands[0]))

    self.parts = [[0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0],
                  [0]]

    self.lead_time = [3]


    self.production_cost = [[70, 70, 70, 70, 140, 140, 140, 140, 140, 70, 70, 70, 70, 70, 70, 70]]
    self.first_inventory = [70]
    self.inventory_cost = [[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]]
    self.setup_cost = [200] * len(self.demands)

    capacity = [6.4 * 60 * 4, 6 * 60 * 2, 7.2 * 60, 7.6 * 60, 7.6 * 60, 7.84 * 60]
    self.capacity = [[element] * len(self.days) for element in capacity]

    self.production_rate = [[0, 1.5, 0.9, 0, 0, 0]]
    self.setup_time = [[0, 30, 5, 0, 0, 0]]

    self.machines = range(len(self.production_rate[0]))


start_time = time.time()
data = data_generator_MRP_beam()
PRODUCTION_PLAN, obj = opt_production_plan_3(data)
end_time = time.time()

run_time = end_time - start_time
for product in range(len(data.demands)):
  display(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]).round(0))
print('objective is : ', round(obj), '. Run time is : ', run_time)

2024-06-14 01:16:19,795 - DEBUG - Solver created.
2024-06-14 01:16:19,796 - DEBUG - Variables created.
2024-06-14 01:16:19,797 - DEBUG - Objective function added.
2024-06-14 01:16:19,799 - DEBUG - All constraints added.
2024-06-14 01:16:19,801 - DEBUG - Objective function set to minimize.
2024-06-14 01:16:19,803 - DEBUG - Solving the model, solver status: 0
2024-06-14 01:16:19,804 - DEBUG - Optimal solution found.

objective is :  22780 . Run time is :  0.01726818084716797

def opt_production_plan_3(data):
  logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
  # Create the mip solver with the SCIP backend.
  m = pywraplp.Solver.CreateSolver('SCIP')
  logging.debug("Solver created.")
  # decision variables
  obj = m.NumVar(0, 1000000000, 'obj')

  setup = []
  production = []
  inventory = []
  for product in range(len(data.demands)):
    setup_temp = []
    production_temp = []
    inventory_temp = []
    for day in range(len(data.days)):
        suffix = '_{}_{}'.format(product, day)
        setup_temp.append(m.BoolVar('setup' + suffix))
        production_temp.append(m.NumVar(0, 100000, 'production' + suffix))
        inventory_temp.append(m.NumVar(0, 100000, 'inventory' + suffix))

    setup.append(setup_temp)
    production.append(production_temp)
    inventory.append(inventory_temp)
  logging.debug("Variables created.")


  # Objective function setup
  objective_terms = []
  for product in range(len(data.demands)):
      for day in range(len(data.days)):
          term = production[product][day] * data.production_cost[product][day] \
              + setup[product][day] * data.setup_cost[product] \
              + inventory[product][day] * data.inventory_cost[product][day]
          objective_terms.append(term)

  m.Add(obj >= sum(objective_terms))

  logging.debug("Objective function added.")
  # Demand constraint
  for product in range(len(data.demands)):
    for day in data.days:
      # Setup constraint
      #logging.debug(f"Adding setup constraint for product {product}, day {day}.")
      m.Add(production[product][day] <= 100000 * setup[product][day])
      #logging.debug(f"Setup constraint for product {product}, day {day} added.")

      if day != 0:
        if day - data.lead_time[product] >= 0:
            m.Add(inventory[product][day-1] + production[product][day - data.lead_time[product]] == \
                  (data.demands[product][day] + sum(data.parts[unit][product] * production[unit][day] for unit in range(len(data.demands)))) + inventory[product][day])
        else:
          m.Add(inventory[product][day-1] == (data.demands[product][day] + sum(data.parts[unit][product] * production[unit][day] for unit in range(len(data.demands)))) + inventory[product][day])
      else:
        m.Add(data.first_inventory[product] == (data.demands[product][0] + sum(data.parts[unit][product] * production[unit][0] for unit in range(len(data.demands)))) + inventory[product][0])
      #logging.debug(f"Demand balance constraint for product {product}, day {day} added.")

  logging.debug("All constraints added.")

      # Capacity constraint
  for day in data.days:
    for machine in data.machines:
      m.Add(sum(data.production_rate[product][machine] * production[product][day] + \
                data.setup_time[product][machine] * setup[product][day] \
                for product in range(len(data.demands))) <= data.capacity[machine][day])

  # objective function
  m.Minimize(obj)
  logging.debug("Objective function set to minimize.")
  # solving the model
  status = m.Solve()
  logging.debug(f"Solving the model, solver status: {status}")
  if status == pywraplp.Solver.OPTIMAL:

      PRODUCTION_PLAN = {}
      for product in range(len(data.demands)):
        PRODUCTION_PLAN_temp = {}
        for m_idx, day in enumerate(data.days):
            PRODUCTION_PLAN_temp[day] = {
                'product ' + str(product):   production[product][m_idx].solution_value(), \
                'setup':                     setup[product][m_idx].solution_value(), \
                'inventory':                 inventory[product][m_idx].solution_value()
                }
        PRODUCTION_PLAN[product] = PRODUCTION_PLAN_temp
      logging.debug("Optimal solution found.")
      return PRODUCTION_PLAN, obj.solution_value()

  elif status == pywraplp.Solver.FEASIBLE:
      logging.debug("Solver found a feasible solution, not necessarily optimal.")
  elif status == pywraplp.Solver.INFEASIBLE:
      logging.debug("Solver found the problem to be infeasible.")
  elif status == pywraplp.Solver.UNBOUNDED:
      logging.debug("Solver found the problem to be unbounded.")
  else:
      logging.debug("Solver ended with an unknown status.")

class ProjectData:

  def __init__(self):

    self.demands = [
            [0, 0, 0, 0, 0, 18, 15, 16, 12, 14, 19, 10, 13, 11, 17, 12],  # Table demand
            [0]*16,  # Tabletop demand
            [0]*16,  # Leg demand
            [0, 0, 0, 0, 0, 5, 7, 4, 6, 7, 3, 6, 5, 4, 7, 6],  # Beam demand
            [0]*16,  # Screw demand
            [0]*16,  # Plank demand
            [0]*16,  # Bracket demand
            [0]*16   # Glue demand
        ]

    self.days = range(len(self.demands[0]))

    self.parts = [
            [0, 1, 4, 2, 0, 0, 0, 0],  # Table
            [0, 0, 0, 0, 8, 1, 4, 0],  # Tabletop
            [0, 0, 0, 0, 8, 4, 4, 1],  # Leg
            [0, 0, 0, 0, 4, 2, 4, 1],  # Beam
            [0, 0, 0, 0, 0, 0, 0, 0],  # Screws
            [0, 0, 0, 0, 0, 0, 0, 1],  # Plank
            [0, 0, 0, 0, 0, 0, 0, 0],  # Brackets
            [0, 0, 0, 0, 0, 0, 0, 0]   # Glue
        ]

    self.lead_time = [3, 2, 2, 3, 1, 1, 1, 1]

    self.production_cost = [
            [100] * 16,
            [30] * 16,
            [40] * 16,
            [70] * 16,
            [40] * 16,
            [60] * 16,
            [80] * 16,
            [30] * 16
        ]
    # Updating production costs for high-demand periods
    high_demand_start, high_demand_end = 4, 9  # Days 5 to 9 (0-indexed as 4 to 8)
    affected_items = [0, 1, 2, 3]  # Table, Tabletop, Leg, Beams
    print("Production costs before update:", self.production_cost)
    for day in range(high_demand_start, high_demand_end):
        for item in affected_items:
            self.production_cost[item][day] *= 2
    print("Production costs after update:", self.production_cost)

    self.first_inventory = [0, 20, 100, 70, 50, 100, 50, 100]
    # Initialize inventory costs with last 5 days adjusted for the table
    self.inventory_cost = [
        [20] * 16,
        [10] * 16,
        [10] * 16,
        [10] * 16,
        [5] * 16,
        [5] * 16,
        [5] * 16,
        [5] * 16
    ]
    print(self.inventory_cost)
    for day in range(11, 16):  # Days 12 to 16 (0-indexed as 11 to 15)
      self.inventory_cost[0][day] = 100  # Correctly accessing the first product's cost array

    print(self.inventory_cost)
    self.setup_cost = [500, 200, 200, 200, 200, 200, 200, 200]

    capacity = [6.4 * 60 * 4, 6 * 60 * 3, 7.2 * 60, 7.6 * 60, 7.6 * 60, 7.84 * 60]

    self.capacity = [[element] * len(self.days) for element in capacity]

    self.production_rate = [[0, 0, 0, 3, 1.5, 2],  # Table
                            [0, 1.5, 0.9, 0, 0, 0],  # Tabletop
                            [0, 1.5, 0.9, 0, 0, 0],  # Leg
                            [0, 1.5, 0.9, 0, 0, 0],  # Beam
                            [0, 0, 0, 0, 0, 0],  # Screws
                            [1, 0, 0, 0, 0, 0],  # Plank
                            [0, 0, 0, 0, 0, 0],  # Brackets
                            [0, 0, 0, 0, 0, 0]]  # Glue

    self.setup_time = [[0, 0, 0, 0, 0, 0],  # Table
                       [0, 30, 5, 0, 0, 0],  # Tabletop
                       [0, 30, 5, 0, 0, 0],  # Leg
                       [0, 30, 5, 0, 0, 0],  # Beam
                       [0, 0, 0, 0, 0, 0],  # Screws
                       [0, 0, 0, 0, 0, 0],  # Plank
                       [0, 0, 0, 0, 0, 0],  # Brackets
                       [0, 0, 0, 0, 0, 0]]  # Glue

    self.machines = range(len(self.production_rate[0]))
start_time = time.time()
data = ProjectData()
PRODUCTION_PLAN, obj = opt_production_plan_3(data)
end_time = time.time()

run_time = end_time - start_time
for product in range(len(data.demands)):
    # print(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]))
  display(pd.DataFrame.from_dict(PRODUCTION_PLAN[product]).round(0))
print('objective is : ', round(obj), '. Run time is : ', run_time)

2024-06-10 13:18:43,653 - DEBUG - Solver created.
2024-06-10 13:18:43,654 - DEBUG - Variables created.
2024-06-10 13:18:43,658 - DEBUG - Objective function added.
2024-06-10 13:18:43,678 - DEBUG - All constraints added.
2024-06-10 13:18:43,696 - DEBUG - Objective function set to minimize.

Production costs before update: [[100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100], [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30], [40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40], [70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70], [40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40], [60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60], [80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80], [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30]]
Production costs after update: [[100, 100, 100, 100, 200, 200, 200, 200, 200, 100, 100, 100, 100, 100, 100, 100], [30, 30, 30, 30, 60, 60, 60, 60, 60, 30, 30, 30, 30, 30, 30, 30], [40, 40, 40, 40, 80, 80, 80, 80, 80, 40, 40, 40, 40, 40, 40, 40], [70, 70, 70, 70, 140, 140, 140, 140, 140, 70, 70, 70, 70, 70, 70, 70], [40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40], [60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60], [80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80], [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30]]
[[20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]]
[[20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 100, 100, 100, 100, 100], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]]

2024-06-10 13:18:43,948 - DEBUG - Solving the model, solver status: 0
2024-06-10 13:18:43,950 - DEBUG - Optimal solution found.

objective is :  929369 . Run time is :  0.3199882507324219

data = pd.read_csv('data/data_project_1.csv')
data

def time_to_continuous_minutes(day, hour, minute):
    # Maps each day to a start minute in the continuous timeline
    days_in_continuous_minutes = {
        'Monday': 0,
        'Tuesday': 1 * 600,
        'Wednesday': 2 * 600,
        'Thursday': 3 * 600,
        'Friday': 4 * 600
    }
    # Calculate the start minute for the given day and add the hour and minute offset
    return days_in_continuous_minutes[day] + (hour - 8) * 60 + minute

JOBS = {
    '1': {'release': 0, 'duration': 2 * 60 + 45, 'due': 0, 'weight': 1},
    '2': {'release': 0, 'duration': 1 * 60 + 45, 'due': 0, 'weight': 3},
    '3': {'release': 0, 'duration': 2 * 60 + 45, 'due': 0, 'weight': 4},
    '4': {'release': 0, 'duration': 2 * 60, 'due': 0, 'weight': 1},
    '5': {'release': 0, 'duration': 2 * 60 + 30, 'due': 0, 'weight': 1},
    '6': {'release': 0, 'duration': 3 * 60 + 15, 'due': 0, 'weight': 2},
    '7': {'release': 0, 'duration': 1 * 60 + 30, 'due': 0, 'weight': 3},
    '8': {'release': 0, 'duration': 1 * 60 + 15, 'due': 0, 'weight': 1},
    '9': {'release': 0, 'duration': 3 * 60, 'due': 0, 'weight': 2},
    '10': {'release': 0, 'duration': 3 * 60, 'due': 0, 'weight': 1},
    '11': {'release': 0, 'duration': 3 * 60 + 45, 'due': 0, 'weight': 1},
    '12': {'release': 0, 'duration': 1 * 60 + 15, 'due': 0, 'weight': 1},
    '13': {'release': 0, 'duration': 45, 'due': 0, 'weight': 1},
    '14': {'release': 0, 'duration': 2 * 60 + 15, 'due': 0, 'weight': 1},
    '15': {'release': 0, 'duration': 1 * 60, 'due': 0, 'weight': 3},
    '16': {'release': 0, 'duration': 2 * 60 + 45, 'due': 0, 'weight': 4},
    '17': {'release': 0, 'duration': 2 * 60 + 30, 'due': 0, 'weight': 4},
}

MACHINES = ['A', 'B', 'C']

def gantt(JOBS, SCHEDULE={}):
    bw = 0.3
    plt.figure(figsize=(12, 0.7*(len(JOBS.keys()))))
    idx = 0
    for j in sorted(JOBS.keys()):
        x = JOBS[j]['release']
        y = JOBS[j]['due']
        plt.fill_between([x,y],[idx-bw,idx-bw],[idx+bw,idx+bw], color='cyan', alpha=0.6)
        if j in SCHEDULE.keys():
            x = SCHEDULE[j]['start']
            y = SCHEDULE[j]['finish']
            plt.fill_between([x,y],[idx-bw,idx-bw],[idx+bw,idx+bw], color='grey', alpha=0.5)
            plt.plot([x,y,y,x,x], [idx-bw,idx-bw,idx+bw,idx+bw,idx-bw],color='k')
            plt.text((SCHEDULE[j]['start'] + SCHEDULE[j]['finish'])/2.0,idx,
                'Job ' + j, color='purple', weight='bold',
                horizontalalignment='center', verticalalignment='center')
        idx += 1

    plt.ylim(-0.5, idx-0.5)
    plt.title('Job Schedule')
    plt.xlabel('Time')
    plt.ylabel('Jobs')
    plt.yticks(range(len(JOBS)), JOBS.keys())
    plt.grid()
    xlim = plt.xlim()

    if SCHEDULE:
        for j in SCHEDULE.keys():
            if 'machine' not in SCHEDULE[j].keys():
                SCHEDULE[j]['machine'] = 1
        MACHINES = sorted(set([SCHEDULE[j]['machine'] for j in SCHEDULE.keys()]))

        plt.figure(figsize=(12, 0.7*len(MACHINES)))
        for j in sorted(SCHEDULE.keys()):
            idx = MACHINES.index(SCHEDULE[j]['machine'])
            x = SCHEDULE[j]['start']
            y = SCHEDULE[j]['finish']
            plt.fill_between([x,y],[idx-bw,idx-bw],[idx+bw,idx+bw], color='grey', alpha=0.5)
            plt.plot([x,y,y,x,x], [idx-bw,idx-bw,idx+bw,idx+bw,idx-bw],color='k')
            plt.text((SCHEDULE[j]['start'] + SCHEDULE[j]['finish'])/2.0,idx,
                'Job ' + j, color='purple', weight='bold',
                horizontalalignment='center', verticalalignment='center', rotation=30)
        plt.xlim(xlim)
        plt.ylim(-0.5, len(MACHINES)-0.5)
        plt.title('Machine Schedule')
        plt.yticks(range(len(MACHINES)), MACHINES)
        plt.ylabel('Machines')
        plt.grid()


def kpi(JOBS, SCHEDULE):
    KPI = {}
    KPI['Makespan'] = max(SCHEDULE[job]['finish'] for job in SCHEDULE)
    KPI['Max Pastdue'] = max(max(0, SCHEDULE[job]['finish'] - JOBS[job]['due']) for job in SCHEDULE)
    KPI['Sum of Pastdue'] = sum(max(0, SCHEDULE[job]['finish'] - JOBS[job]['due']) for job in SCHEDULE)
    KPI['Number Pastdue'] = sum(SCHEDULE[job]['finish'] > JOBS[job]['due'] for job in SCHEDULE)
    KPI['Number on Time'] = sum(SCHEDULE[job]['finish'] <= JOBS[job]['due'] for job in SCHEDULE)
    KPI['Fraction on Time'] = KPI['Number on Time']/len(SCHEDULE)
    return KPI

def milp(JOBS, MACHINES):

    # Create the mip solver with the SCIP backend.
    m = pywraplp.Solver.CreateSolver('SCIP')

    #Big M
    BigM = sum([JOBS[j]['duration'] for j in JOBS.keys()])

    # decision variables
    completion_time = []
    for job_id in JOBS.keys():
        suffix = '_%s' % job_id
        completion_time.append(m.NumVar(0,BigM,'C' + suffix))


    # additional decision variables for use in the objecive
    makespan = m.NumVar(0, BigM, 'makespan')

    # for binary assignment of jobs to machines
    assignJob2Mch = []
    for job_id in JOBS.keys():
        assignJob2Mch_nested = []
        for mch in MACHINES:
            # suffix = '_%s_%s' % (job,m)
            suffix = '_%s' % job_id
            assignJob2Mch_nested.append(m.BoolVar('z' + suffix))
        assignJob2Mch.append(assignJob2Mch_nested)


    # for modeling disjunctive constraints
    auxilaryVar = []
    for job in range(len(JOBS.keys())):
        auxilaryVar_nested = []
        for job_k in JOBS.keys():
            auxilaryVar_nested.append(m.BoolVar('y' + suffix))
        auxilaryVar.append(auxilaryVar_nested)


    # constraints
    for mach in range(len(MACHINES)):
        m.Add(sum(assignJob2Mch[j][mach]*JOBS[job_id]['duration'] for j,job_id in enumerate(JOBS.keys())) <= makespan)
    for j,job_id in enumerate(JOBS.keys()):
        m.Add(completion_time[j] <= makespan)
        m.Add(completion_time[j] >= JOBS[job_id]['duration'] + JOBS[job_id]['release'])
        m.Add(sum(assignJob2Mch[j][mach] for mach in range(len(MACHINES))) == 1)
        for k,job_id_k in enumerate(JOBS.keys()):
            if k !=j:
                for mch in range(len(MACHINES)):
                    m.Add(completion_time[j] + JOBS[job_id_k]['duration'] <= completion_time[k] + BigM*(auxilaryVar[j][k] + (1-assignJob2Mch[j][mch]) + (1-assignJob2Mch[k][mch])))
                    m.Add(completion_time[k] + JOBS[job_id]['duration'] <= completion_time[j] + BigM*((1 - auxilaryVar[j][k]) + (1-assignJob2Mch[j][mch]) + (1-assignJob2Mch[k][mch])))

    # objective function
    m.Minimize(makespan)

    status = m.Solve()
    # print(m.VerifySolution(0,True))

    if status == pywraplp.Solver.OPTIMAL:

        SCHEDULE = {}
        for j,job_id in enumerate(JOBS.keys()):
            mm = [mach for mach in range(len(MACHINES)) if assignJob2Mch[j][mach].solution_value()==1]
            SCHEDULE[job_id] = {'machine': MACHINES[mm[0]],
                                'start': completion_time[j].solution_value() - JOBS[job_id]['duration'],
                                'finish': completion_time[j].solution_value() }
        print(SCHEDULE)
        print(m.Objective().Value())
        return SCHEDULE

    else:
        print('The problem does not have an optimal solution.')

def schedule(JOBS, order=sorted(JOBS.keys())):
    """Schedule a dictionary of JOBS on a single machine in a specified order."""
    start = 0
    finish = 0
    SCHEDULE = {}

    machine_finish = [0,0,0]
    for job in order:
        available_machine = machine_finish.index(min(machine_finish))
        start = max(JOBS[job]['release'], min(machine_finish))
        finish = start + JOBS[job]['duration']
        SCHEDULE[job] = {'machine': MACHINES[available_machine],'start': start, 'finish': finish}
        machine_finish[available_machine] = finish
    return SCHEDULE

SCHEDULE = milp(JOBS, MACHINES)
gantt(JOBS, SCHEDULE)
kpi(JOBS, SCHEDULE)

{'1': {'machine': 'C', 'start': 105.0, 'finish': 270.0}, '2': {'machine': 'C', 'start': 0.0, 'finish': 105.0}, '3': {'machine': 'B', 'start': 180.0, 'finish': 345.0}, '4': {'machine': 'A', 'start': 45.0, 'finish': 165.0}, '5': {'machine': 'A', 'start': 614.9999999999999, 'finish': 764.9999999999999}, '6': {'machine': 'C', 'start': 420.0, 'finish': 615.0}, '7': {'machine': 'A', 'start': 300.0, 'finish': 390.0}, '8': {'machine': 'B', 'start': 510.0, 'finish': 585.0}, '9': {'machine': 'B', 'start': -5.684341886080802e-14, 'finish': 179.99999999999994}, '10': {'machine': 'B', 'start': 584.9999999999999, 'finish': 764.9999999999999}, '11': {'machine': 'A', 'start': 390.0, 'finish': 615.0}, '12': {'machine': 'A', 'start': 165.0, 'finish': 240.0}, '13': {'machine': 'A', 'start': 0.0, 'finish': 45.0}, '14': {'machine': 'C', 'start': 615.0, 'finish': 750.0}, '15': {'machine': 'A', 'start': 240.0, 'finish': 300.0}, '16': {'machine': 'B', 'start': 344.9999999999999, 'finish': 509.9999999999999}, '17': {'machine': 'C', 'start': 270.0, 'finish': 420.0}}
765.0

{'Makespan': 764.9999999999999,
 'Max Pastdue': 764.9999999999999,
 'Sum of Pastdue': 7065.0,
 'Number Pastdue': 17,
 'Number on Time': 0,
 'Fraction on Time': 0.0}

SCHEDULE = schedule(JOBS)
SCHEDULE
order=sorted(JOBS,reverse = True, key=lambda x: (JOBS[x]['duration'], x))

gantt(JOBS, schedule(JOBS,order))
kpi(JOBS, schedule(JOBS,order))
print(sorted(SCHEDULE.keys()))
kpi(JOBS, SCHEDULE)

['1', '10', '11', '12', '13', '14', '15', '16', '17', '2', '3', '4', '5', '6', '7', '8', '9']

{'Makespan': 840,
 'Max Pastdue': 840,
 'Sum of Pastdue': 7665,
 'Number Pastdue': 17,
 'Number on Time': 0,
 'Fraction on Time': 0.0}

order=sorted(JOBS,reverse = True, key=lambda x: (JOBS[x]['weight']/JOBS[x]['duration'], x))
print(order)
print([JOBS[x]['weight']/JOBS[x]['duration'] for x in JOBS]) #it prints not in order
gantt(JOBS, schedule(JOBS,order)) 
kpi(JOBS, schedule(JOBS,order))

['15', '7', '2', '17', '3', '16', '13', '8', '12', '9', '6', '4', '14', '5', '1', '10', '11']
[0.006060606060606061, 0.02857142857142857, 0.024242424242424242, 0.008333333333333333, 0.006666666666666667, 0.010256410256410256, 0.03333333333333333, 0.013333333333333334, 0.011111111111111112, 0.005555555555555556, 0.0044444444444444444, 0.013333333333333334, 0.022222222222222223, 0.007407407407407408, 0.05, 0.024242424242424242, 0.02666666666666667]

{'Makespan': 825,
 'Max Pastdue': 825,
 'Sum of Pastdue': 6795,
 'Number Pastdue': 17,
 'Number on Time': 0,
 'Fraction on Time': 0.0}

order=sorted(JOBS, key=lambda x: (JOBS[x]['duration'], x))
print(order)
gantt(JOBS, schedule(JOBS,order))
kpi(JOBS, schedule(JOBS,order))

['13', '15', '12', '8', '7', '2', '4', '14', '17', '5', '1', '16', '3', '10', '9', '6', '11']

{'Makespan': 855,
 'Max Pastdue': 855,
 'Sum of Pastdue': 6285,
 'Number Pastdue': 17,
 'Number on Time': 0,
 'Fraction on Time': 0.0}

def print_job_order(JOBS, order):
    data = {
        'Job': [],
        'Start (min)': [],
        'Duration (min)': [],
        'Due (min)': [],
        'Weight': []
    }
    
    for job in order:
        data['Job'].append(job)
        data['Start (min)'].append(JOBS[job]['release'])
        data['Duration (min)'].append(JOBS[job]['duration'])
        data['Due (min)'].append(JOBS[job]['due'])
        data['Weight'].append(JOBS[job]['weight'])
        
    df = pd.DataFrame(data)
    display(df)

# LPT - Largest Processing Time first
lpt_order = sorted(JOBS, reverse=True, key=lambda x: (JOBS[x]['duration'], x))
print("LPT Order:")
print_job_order(JOBS, lpt_order)

# WSPT - Weighted Shortest Processing Time first
wspt_order = sorted(JOBS, reverse=True, key=lambda x: (JOBS[x]['weight'] / JOBS[x]['duration'], x))
print("\nWSPT Order:")
print_job_order(JOBS, wspt_order)

# SPT - Shortest Processing Time first
spt_order = sorted(JOBS, key=lambda x: (JOBS[x]['duration'], x))
print("\nSPT Order:")
print_job_order(JOBS, spt_order)

LPT Order:

WSPT Order:

SPT Order:

JOBS = {
    '1': {'release': time_to_continuous_minutes('Tuesday', 16, 45), 'duration': 2 * 60 + 45, 'due': 0, 'weight': 1},
    '2': {'release': time_to_continuous_minutes('Monday', 15, 45), 'duration': 1 * 60 + 45, 'due': 0, 'weight': 3},
    '3': {'release': time_to_continuous_minutes('Monday', 17, 45), 'duration': 2 * 60 + 45, 'due': 0, 'weight': 4},
    '4': {'release': time_to_continuous_minutes('Monday', 8, 30), 'duration': 2 * 60, 'due': 0, 'weight': 1},
    '5': {'release': time_to_continuous_minutes('Monday', 10, 30), 'duration': 2 * 60 + 30, 'due': 0, 'weight': 1},
    '6': {'release': time_to_continuous_minutes('Tuesday', 16, 0), 'duration': 3 * 60 + 15, 'due': 0, 'weight': 2},
    '7': {'release': time_to_continuous_minutes('Tuesday', 16, 30), 'duration': 1 * 60 + 30, 'due': 0, 'weight': 3},
    '8': {'release': time_to_continuous_minutes('Tuesday', 17, 45), 'duration': 1 * 60 + 15, 'due': 0, 'weight': 1},
    '9': {'release': time_to_continuous_minutes('Monday', 13, 30), 'duration': 3 * 60, 'due': 0, 'weight': 2},
    '10': {'release': time_to_continuous_minutes('Monday', 17, 15), 'duration': 3 * 60, 'due': 0, 'weight': 1},
    '11': {'release': time_to_continuous_minutes('Tuesday', 15, 45), 'duration': 3 * 60 + 45, 'due': 0, 'weight': 1},
    '12': {'release': time_to_continuous_minutes('Monday', 15, 45), 'duration': 1 * 60 + 15, 'due': 0, 'weight': 1},
    '13': {'release': time_to_continuous_minutes('Monday', 15, 30), 'duration': 45, 'due': 0, 'weight': 1},
    '14': {'release': time_to_continuous_minutes('Monday', 9, 30), 'duration': 2 * 60 + 15, 'due': 0, 'weight': 1},
    '15': {'release': time_to_continuous_minutes('Tuesday', 13, 0), 'duration': 1 * 60, 'due': 0, 'weight': 3},
    '16': {'release': time_to_continuous_minutes('Tuesday', 17, 0), 'duration': 2 * 60 + 45, 'due': 0, 'weight': 4},
    '17': {'release': time_to_continuous_minutes('Monday', 15, 30), 'duration': 2 * 60 + 30, 'due': 0, 'weight': 4},
}

MACHINES = ['A', 'B', 'C']

JOBS

{'1': {'release': 1125, 'duration': 165, 'due': 0, 'weight': 1},
 '2': {'release': 465, 'duration': 105, 'due': 0, 'weight': 3},
 '3': {'release': 585, 'duration': 165, 'due': 0, 'weight': 4},
 '4': {'release': 30, 'duration': 120, 'due': 0, 'weight': 1},
 '5': {'release': 150, 'duration': 150, 'due': 0, 'weight': 1},
 '6': {'release': 1080, 'duration': 195, 'due': 0, 'weight': 2},
 '7': {'release': 1110, 'duration': 90, 'due': 0, 'weight': 3},
 '8': {'release': 1185, 'duration': 75, 'due': 0, 'weight': 1},
 '9': {'release': 330, 'duration': 180, 'due': 0, 'weight': 2},
 '10': {'release': 555, 'duration': 180, 'due': 0, 'weight': 1},
 '11': {'release': 1065, 'duration': 225, 'due': 0, 'weight': 1},
 '12': {'release': 465, 'duration': 75, 'due': 0, 'weight': 1},
 '13': {'release': 450, 'duration': 45, 'due': 0, 'weight': 1},
 '14': {'release': 90, 'duration': 135, 'due': 0, 'weight': 1},
 '15': {'release': 900, 'duration': 60, 'due': 0, 'weight': 3},
 '16': {'release': 1140, 'duration': 165, 'due': 0, 'weight': 4},
 '17': {'release': 450, 'duration': 150, 'due': 0, 'weight': 4}}

SCHEDULE = milp(JOBS, MACHINES)
gantt(JOBS, SCHEDULE)
kpi(JOBS, SCHEDULE)

{'1': {'machine': 'C', 'start': 1200.0000000000002, 'finish': 1365.0000000000002}, '2': {'machine': 'A', 'start': 465.0, 'finish': 570.0}, '3': {'machine': 'A', 'start': 585.0, 'finish': 750.0}, '4': {'machine': 'B', 'start': 30.0, 'finish': 150.0}, '5': {'machine': 'A', 'start': 225.00000000000085, 'finish': 375.00000000000085}, '6': {'machine': 'B', 'start': 1080.0, 'finish': 1275.0}, '7': {'machine': 'C', 'start': 1110.0, 'finish': 1200.0}, '8': {'machine': 'A', 'start': 1290.0, 'finish': 1365.0}, '9': {'machine': 'B', 'start': 854.9999999999991, 'finish': 1034.999999999999}, '10': {'machine': 'C', 'start': 555.0, 'finish': 735.0}, '11': {'machine': 'A', 'start': 1065.0, 'finish': 1290.0}, '12': {'machine': 'C', 'start': 465.0, 'finish': 540.0}, '13': {'machine': 'B', 'start': 1034.9999999999998, 'finish': 1079.9999999999998}, '14': {'machine': 'A', 'start': 90.0, 'finish': 225.0}, '15': {'machine': 'A', 'start': 900.0, 'finish': 960.0}, '16': {'machine': 'B', 'start': 1275.0000000000002, 'finish': 1440.0000000000002}, '17': {'machine': 'B', 'start': 450.0, 'finish': 600.0}}
1440.0

{'Makespan': 1440.0000000000002,
 'Max Pastdue': 1440.0000000000002,
 'Sum of Pastdue': 14955.0,
 'Number Pastdue': 17,
 'Number on Time': 0,
 'Fraction on Time': 0.0}

SCHEDULE = schedule(JOBS)
SCHEDULE

order=sorted(JOBS,reverse = True, key=lambda x: (JOBS[x]['duration'], x))
print("LPT Order:")
print_job_order(JOBS, order)
gantt(JOBS, schedule(JOBS,order))
kpi(JOBS, schedule(JOBS,order))

LPT Order:

{'Makespan': 1695,
 'Max Pastdue': 1695,
 'Sum of Pastdue': 23370,
 'Number Pastdue': 17,
 'Number on Time': 0,
 'Fraction on Time': 0.0}

JOBS = {
    '1': {'release': time_to_continuous_minutes('Tuesday', 16, 45), 'duration': 2 * 60 + 45, 'due': time_to_continuous_minutes('Wednesday', 10, 30), 'weight': 1},
    '2': {'release': time_to_continuous_minutes('Monday', 15, 45), 'duration': 1 * 60 + 45, 'due': time_to_continuous_minutes('Wednesday', 12, 0), 'weight': 3},
    '3': {'release': time_to_continuous_minutes('Monday', 17, 45), 'duration': 2 * 60 + 45, 'due': time_to_continuous_minutes('Thursday', 11, 45), 'weight': 4},
    '4': {'release': time_to_continuous_minutes('Monday', 8, 30), 'duration': 2 * 60, 'due': time_to_continuous_minutes('Wednesday', 13, 45), 'weight': 1},
    '5': {'release': time_to_continuous_minutes('Monday', 10, 30), 'duration': 2 * 60 + 30, 'due': time_to_continuous_minutes('Tuesday', 8, 30), 'weight': 1},
    '6': {'release': time_to_continuous_minutes('Tuesday', 16, 0), 'duration': 3 * 60 + 15, 'due': time_to_continuous_minutes('Thursday', 17, 30), 'weight': 2},
    '7': {'release': time_to_continuous_minutes('Tuesday', 16, 30), 'duration': 1 * 60 + 30, 'due': time_to_continuous_minutes('Wednesday', 13, 30), 'weight': 3},
    '8': {'release': time_to_continuous_minutes('Tuesday', 17, 45), 'duration': 1 * 60 + 15, 'due': time_to_continuous_minutes('Friday', 9, 45), 'weight': 1},
    '9': {'release': time_to_continuous_minutes('Monday', 13, 30), 'duration': 3 * 60, 'due': time_to_continuous_minutes('Thursday', 14, 15), 'weight': 2},
    '10': {'release': time_to_continuous_minutes('Monday', 17, 15), 'duration': 3 * 60, 'due': time_to_continuous_minutes('Wednesday', 12, 30), 'weight': 1},
    '11': {'release': time_to_continuous_minutes('Tuesday', 15, 45), 'duration': 3 * 60 + 45, 'due': time_to_continuous_minutes('Thursday', 13, 30), 'weight': 1},
    '12': {'release': time_to_continuous_minutes('Monday', 15, 45), 'duration': 1 * 60 + 15, 'due': time_to_continuous_minutes('Tuesday', 15, 0), 'weight': 1},
    '13': {'release': time_to_continuous_minutes('Monday', 15, 30), 'duration': 45, 'due': time_to_continuous_minutes('Tuesday', 16, 45), 'weight': 1},
    '14': {'release': time_to_continuous_minutes('Monday', 9, 30), 'duration': 2 * 60 + 15, 'due': time_to_continuous_minutes('Tuesday', 13, 30), 'weight': 1},
    '15': {'release': time_to_continuous_minutes('Tuesday', 13, 0), 'duration': 1 * 60, 'due': time_to_continuous_minutes('Tuesday', 15, 45), 'weight': 3},
    '16': {'release': time_to_continuous_minutes('Tuesday', 17, 0), 'duration': 2 * 60 + 45, 'due': time_to_continuous_minutes('Friday', 17, 0), 'weight': 4},
    '17': {'release': time_to_continuous_minutes('Monday', 15, 30), 'duration': 2 * 60 + 30, 'due': time_to_continuous_minutes('Wednesday', 8, 45), 'weight': 4},
}

MACHINES = ['A', 'B', 'C']

order=sorted(JOBS, key=lambda x: (JOBS[x]['duration'], x))
gantt(JOBS, schedule(JOBS,order))
kpi(JOBS, schedule(JOBS,order))
# SPT 
print("\nEDD Order:")
print_job_order(JOBS, order)
kpi(JOBS, SCHEDULE)

EDD Order:

{'Makespan': 1785,
 'Max Pastdue': 960,
 'Sum of Pastdue': 1290,
 'Number Pastdue': 4,
 'Number on Time': 13,
 'Fraction on Time': 0.7647058823529411}

order = sorted(JOBS, key=lambda x: (JOBS[x]['due'], x))
gantt(JOBS, schedule(JOBS,order))
kpi(JOBS, schedule(JOBS,order))
# EDD - Earliest Due Date first
print("\nEDD Order:")
print_job_order(JOBS, order)
kpi(JOBS, SCHEDULE)

EDD Order:

{'Makespan': 1785,
 'Max Pastdue': 960,
 'Sum of Pastdue': 1290,
 'Number Pastdue': 4,
 'Number on Time': 13,
 'Fraction on Time': 0.7647058823529411}

def opt_schedule(JOBS):

    # Create the mip solver with the SCIP backend.
    m = pywraplp.Solver.CreateSolver('SCIP')

    # upper bounds on how long it would take to process all jobs
    tmax = max([JOBS[job_id]['release'] for job_id in JOBS.keys()]) + sum([JOBS[job_id]['duration'] for job_id in JOBS.keys()])


    # decision variables
    completion_time = []
    auxilaryVar = []
    for job in range(len(JOBS.keys())):
        suffix = '_%s' % job
        completion_time.append(m.NumVar(0, tmax, 'complete' + suffix))

        auxilaryVar_nested=[]
        for job_k in JOBS.keys():
            auxilaryVar_nested.append(m.BoolVar('y' + suffix))
        auxilaryVar.append(auxilaryVar_nested)


    # additional decision variables for use in the objecive
    maxpastdue = m.NumVar(-tmax, tmax, 'maxpastdue')

    # constraints
    for j,job_id in enumerate(JOBS.keys()):
        m.Add(completion_time[j] >= JOBS[job_id]['release'] + JOBS[job_id]['duration'])
        m.Add(maxpastdue >= completion_time[j] - JOBS[job_id]['due'])
        for k,job_id_k in enumerate(JOBS.keys()):
            if k !=j:
                m.Add(completion_time[j] + JOBS[job_id_k]['duration'] <= completion_time[k] + tmax*auxilaryVar[j][k])
                m.Add(completion_time[k] + JOBS[job_id]['duration'] <= completion_time[j] + tmax*(1 - auxilaryVar[j][k]))

    # objective function
    m.Minimize(maxpastdue)

    status = m.Solve()

    if status == pywraplp.Solver.OPTIMAL:
        print(maxpastdue.solution_value())
        SCHEDULE = {}
        for j,job_id in enumerate(JOBS.keys()):
            SCHEDULE[job_id] = {'machine': 1, 'start': completion_time[j].solution_value() - JOBS[job_id]['duration'], 'finish': completion_time[j].solution_value()}
        # print(SCHEDULE)
        return SCHEDULE


    else:
        print('The problem does not have an optimal solution.')


SCHEDULE = opt_schedule(JOBS)
gantt(JOBS, SCHEDULE)
kpi(JOBS, SCHEDULE)

-60.00000000000001

{'Makespan': 2714.9999999999995,
 'Max Pastdue': 0,
 'Sum of Pastdue': 0,
 'Number Pastdue': 0,
 'Number on Time': 17,
 'Fraction on Time': 1.0}

def opt_schedule(JOBS):

    # Create the mip solver with the SCIP backend.
    m = pywraplp.Solver.CreateSolver('SCIP')

    # upper bounds on how long it would take to process all jobs
    tmax = max([JOBS[job_id]['release'] for job_id in JOBS.keys()]) + sum([JOBS[job_id]['duration'] for job_id in JOBS.keys()])


    # decision variables
    completion_time = []
    auxilaryVar = []
    for job in range(len(JOBS.keys())):
        suffix = '_%s' % job
        completion_time.append(m.NumVar(0, tmax, 'complete' + suffix))

        auxilaryVar_nested=[]
        for job_k in JOBS.keys():
            auxilaryVar_nested.append(m.BoolVar('y' + suffix))
        auxilaryVar.append(auxilaryVar_nested)


    # additional decision variables for use in the objecive
    ispastdue = []
    for job_id in JOBS.keys():
        ispastdue.append(m.BoolVar('ispastdue'))

    # constraints
    for j,job_id in enumerate(JOBS.keys()):
        m.Add(completion_time[j] <= JOBS[job_id]['due'] + tmax * ispastdue[j])

        m.Add(completion_time[j] >= JOBS[job_id]['release'] + JOBS[job_id]['duration'])
        for k,job_id_k in enumerate(JOBS.keys()):
            if k !=j:
                m.Add(completion_time[j] + JOBS[job_id_k]['duration'] <= completion_time[k] + tmax*auxilaryVar[j][k])
                m.Add(completion_time[k] + JOBS[job_id]['duration'] <= completion_time[j] + tmax*(1 - auxilaryVar[j][k]))

    # objective function
    m.Minimize(sum(ispastdue))

    status = m.Solve()

    if status == pywraplp.Solver.OPTIMAL:
        print(sum(ispastdue[job_id].solution_value() for job_id in range(len(JOBS.keys()))))
        SCHEDULE = {}
        for j,job_id in enumerate(JOBS.keys()):
            SCHEDULE[job_id] = {'machine': 1, 'start': completion_time[j].solution_value() - JOBS[job_id]['duration'], 'finish': completion_time[j].solution_value()}
        # print(SCHEDULE)
        return SCHEDULE


    else:
        print('The problem does not have an optimal solution.')


SCHEDULE = opt_schedule(JOBS)
gantt(JOBS, SCHEDULE)
kpi(JOBS, SCHEDULE)

0.0

{'Makespan': 2939.9999999999995,
 'Max Pastdue': 4.547473508864641e-13,
 'Sum of Pastdue': 4.547473508864641e-13,
 'Number Pastdue': 1,
 'Number on Time': 16,
 'Fraction on Time': 0.9411764705882353}

order = sorted(JOBS, key=lambda x: (JOBS[x]['due'], x))
# print(order)

Flow_Time = []
j = 0
while j < len(order):
    job = order[j]
    # print(j,job)
    if len(Flow_Time) == 0:
        Flow_Time.append(JOBS[job]['duration'])
    else:
        Flow_Time.append(Flow_Time[-1] + JOBS[job]['duration'])
    # print(Flow_Time)
    if Flow_Time[j] > JOBS[job]['due']:
        remove_ele = np.argmax(np.array([JOBS[i]['duration'] for i in order[:j]]))
        order.pop(remove_ele)
        j = 0
        Flow_Time = []
    else:
        j += 1
    # print(order)

df = pd.DataFrame(np.column_stack((order,np.array([JOBS[job]['duration'] for job in order]),np.array([JOBS[job]['due'] for job in order]),Flow_Time)))
df.columns = ['Job','Processing Time','Due Date','Flow Time']
df.style

data_2 = pd.read_csv('data/data_project_2.csv')
data_2

# Convert inspection times to a list
inspection_times = [int(time * 60) for time in data_2['Needed_Time (Hour)']]
inspection_times

[113, 35, 127, 173, 153, 3, 54, 76, 50, 114, 78, 56, 27, 127, 53, 112, 99]

JOBS = {
    '1': {'release': 1365, 'duration': 113, 'due': time_to_continuous_minutes('Wednesday', 10, 30), 'weight': 1},
    '2': {'release': 570, 'duration': 35, 'due': time_to_continuous_minutes('Wednesday', 12, 0), 'weight': 3},
    '3': {'release': 750, 'duration': 127, 'due': time_to_continuous_minutes('Thursday', 11, 45), 'weight': 4},
    '4': {'release': 150, 'duration': 173, 'due': time_to_continuous_minutes('Wednesday', 13, 45), 'weight': 1},
    '5': {'release': 375, 'duration': 153, 'due': time_to_continuous_minutes('Tuesday', 8, 30), 'weight': 1},
    '6': {'release': 1275, 'duration': 3, 'due': time_to_continuous_minutes('Thursday', 17, 30), 'weight': 2},
    '7': {'release': 1200, 'duration': 54, 'due': time_to_continuous_minutes('Wednesday', 13, 30), 'weight': 3},
    '8': {'release': 1365, 'duration': 76, 'due': time_to_continuous_minutes('Friday', 9, 45), 'weight': 1},
    '9': {'release': 1035, 'duration': 50, 'due': time_to_continuous_minutes('Thursday', 14, 15), 'weight': 2},
    '10': {'release': 735, 'duration': 114, 'due': time_to_continuous_minutes('Wednesday', 12, 30), 'weight': 1},
    '11': {'release': 1290, 'duration': 78, 'due': time_to_continuous_minutes('Thursday', 13, 30), 'weight': 1},
    '12': {'release': 540, 'duration': 56, 'due': time_to_continuous_minutes('Tuesday', 15, 0), 'weight': 1},
    '13': {'release': 1080, 'duration': 27, 'due': time_to_continuous_minutes('Tuesday', 16, 45), 'weight': 1},
    '14': {'release': 225, 'duration': 127, 'due': time_to_continuous_minutes('Tuesday', 13, 30), 'weight': 1},
    '15': {'release': 960, 'duration': 53, 'due': time_to_continuous_minutes('Tuesday', 15, 45), 'weight': 3},
    '16': {'release': 1440, 'duration': 112, 'due': time_to_continuous_minutes('Friday', 17, 0), 'weight': 4},
    '17': {'release': 600, 'duration': 99, 'due': time_to_continuous_minutes('Wednesday', 8, 45), 'weight': 4},
}

MACHINES = ['I']

def schedule(JOBS, order=sorted(JOBS.keys())):
    "Schedule a dictionary of JOBS on a single machine in a specified order."
    start = 0
    finish = 0
    SCHEDULE = {}

    for job in order:
        start = max(JOBS[job]['release'], finish)
        finish = start + JOBS[job]['duration']
        SCHEDULE[job] = {'start': start, 'finish': finish}
    return SCHEDULE

SCHEDULE = schedule(JOBS)
SCHEDULE

order=sorted(JOBS,reverse = True, key=lambda x: (JOBS[x]['duration'], x))
print("LPT Order:")
print_job_order(JOBS, order)
gantt(JOBS, schedule(JOBS,order))
kpi(JOBS, schedule(JOBS,order))

LPT Order:

{'Makespan': 2121,
 'Max Pastdue': 993,
 'Sum of Pastdue': 4533,
 'Number Pastdue': 8,
 'Number on Time': 9,
 'Fraction on Time': 0.5294117647058824}

order=sorted(JOBS, key=lambda x: (JOBS[x]['duration'], x))
gantt(JOBS, schedule(JOBS,order))
kpi(JOBS, schedule(JOBS,order))
# SPT 
print("\nEDD Order:")
print_job_order(JOBS, order)
kpi(JOBS, SCHEDULE)

EDD Order:

{'Makespan': 2815,
 'Max Pastdue': 2002,
 'Sum of Pastdue': 10581,
 'Number Pastdue': 15,
 'Number on Time': 2,
 'Fraction on Time': 0.11764705882352941}

order = sorted(JOBS, key=lambda x: (JOBS[x]['due'], x))
gantt(JOBS, schedule(JOBS,order))
kpi(JOBS, schedule(JOBS,order))
# EDD - Earliest Due Date first
print("\nEDD Order:")
print_job_order(JOBS, order)
kpi(JOBS, SCHEDULE)

EDD Order:

{'Makespan': 2815,
 'Max Pastdue': 2002,
 'Sum of Pastdue': 10581,
 'Number Pastdue': 15,
 'Number on Time': 2,
 'Fraction on Time': 0.11764705882352941}

SCHEDULE = opt_schedule(JOBS)
gantt(JOBS, SCHEDULE)
kpi(JOBS, SCHEDULE)

1.0

{'Makespan': 2890.0,
 'Max Pastdue': 1540.0,
 'Sum of Pastdue': 1540.0,
 'Number Pastdue': 1,
 'Number on Time': 16,
 'Fraction on Time': 0.9411764705882353}

def milp_with_single_delay(JOBS, delay):
    # Create the MIP solver with the SCIP backend.
    solver = pywraplp.Solver.CreateSolver('SCIP')
    if not solver:
        return

    # Big M value
    BigM = 10000

    # Decision variables
    completion_time = {}
    start_time = {}
    y = {}

    for job in JOBS:
        completion_time[job] = solver.NumVar(0, BigM, f'completion_time_{job}')
        start_time[job] = solver.NumVar(0, BigM, f'start_time_{job}')

    for i in JOBS:
        for j in JOBS:
            if i != j:
                y[(i, j)] = solver.BoolVar(f'y_{i}_{j}')

    # Constraints
    for job in JOBS:
        solver.Add(start_time[job] >= JOBS[job]['release'])
        solver.Add(completion_time[job] == start_time[job] + JOBS[job]['duration'])

    for i in JOBS:
        for j in JOBS:
            if i != j:
                if i == 'first_job':
                    solver.Add(start_time[i] + JOBS[i]['duration'] + delay <= start_time[j] + BigM * (1 - y[(i, j)]))
                else:
                    solver.Add(start_time[i] + JOBS[i]['duration'] <= start_time[j] + BigM * (1 - y[(i, j)]))
                solver.Add(start_time[j] + JOBS[j]['duration'] <= start_time[i] + BigM * y[(i, j)])

    # Objective: Minimize the average completion time
    solver.Minimize(solver.Sum([completion_time[job] for job in JOBS]) / len(JOBS))

    # Solve
    status = solver.Solve()

    # Process solution
    if status == pywraplp.Solver.OPTIMAL:
        SCHEDULE = {}
        for job in JOBS:
            SCHEDULE[job] = {
                'start': start_time[job].solution_value(),
                'finish': completion_time[job].solution_value()
            }
        return SCHEDULE
    else:
        return None

# Mark the first job
first_job = '1'

# Run the model with a 15-minute delay after the first job
DELAY = 15
SCHEDULE_WITH_DELAY = milp_with_single_delay(JOBS, DELAY)
gantt(JOBS, SCHEDULE_WITH_DELAY)
kpi(JOBS, SCHEDULE)

{'Makespan': 2890.0,
 'Max Pastdue': 1540.0,
 'Sum of Pastdue': 1540.0,
 'Number Pastdue': 1,
 'Number on Time': 16,
 'Fraction on Time': 0.9411764705882353}

TASKS = {
    ('Natural-Fiber Rug', 'Fiber Processing'): {'dur': 1.0, 'prec': None},
    ('Natural-Fiber Rug', 'Coloring'): {'dur': 5.0, 'prec': ('Natural-Fiber Rug', 'Fiber Processing')},
    ('Natural-Fiber Rug', 'Weaving'): {'dur': 4.0, 'prec': ('Natural-Fiber Rug', 'Coloring')},
    ('Natural-Fiber Rug', 'Inspection'): {'dur': 1.5, 'prec': ('Natural-Fiber Rug', 'Weaving')},
    ('Black & White Rug', 'Weaving'): {'dur': 4.5, 'prec': None},
    ('Black & White Rug', 'Inspection'): {'dur': 1.0, 'prec': ('Black & White Rug', 'Weaving')},
    ('Colored Rug', 'Coloring'): {'dur': 3.0, 'prec': None},
    ('Colored Rug', 'Weaving'): {'dur': 5.0, 'prec': ('Colored Rug', 'Coloring')},
    ('Colored Rug', 'Inspection'): {'dur': 1.5, 'prec': ('Colored Rug', 'Weaving')}
}


TASKS

def visualize(results):

    schedule = pd.DataFrame(results)
    JOBS = sorted(list(schedule['Job'].unique()))
    MACHINES = sorted(list(schedule['Machine'].unique()))
    makespan = schedule['Finish'].max()

    bar_style = {'alpha':1.0, 'lw':25, 'solid_capstyle':'butt'}
    text_style = {'color':'black', 'weight':'bold', 'ha':'center', 'va':'center', 'rotation': 20}
    colors = mpl.cm.Dark2.colors

    schedule.sort_values(by=['Job', 'Start'])
    schedule.set_index(['Job', 'Machine'], inplace=True)

    fig, ax = plt.subplots(2,1, figsize=(12, 5+(len(JOBS)+len(MACHINES))/4))

    for jdx, j in enumerate(JOBS, 1):
        for mdx, m in enumerate(MACHINES, 1):
            if (j,m) in schedule.index:
                xs = schedule.loc[(j,m), 'Start']
                xf = schedule.loc[(j,m), 'Finish']
                ax[0].plot([xs, xf], [jdx]*2, c=colors[mdx%7], **bar_style)
                ax[0].text((xs + xf)/2, jdx, m, **text_style)
                ax[1].plot([xs, xf], [mdx]*2, c=colors[jdx%7], **bar_style)
                ax[1].text((xs + xf)/2, mdx, j, **text_style)

    ax[0].set_title('Job Schedule')
    ax[0].set_ylabel('Job')
    ax[1].set_title('Machine Schedule')
    ax[1].set_ylabel('Machine')

    for idx, s in enumerate([JOBS, MACHINES]):
        ax[idx].set_ylim(0.5, len(s) + 0.5)
        ax[idx].set_yticks(range(1, 1 + len(s)))
        ax[idx].set_yticklabels(s)
        ax[idx].text(makespan, ax[idx].get_ylim()[0]-0.2, "{0:0.1f}".format(makespan), ha='center', va='top')
        ax[idx].plot([makespan]*2, ax[idx].get_ylim(), 'r--')
        ax[idx].set_xlabel('Time')
        ax[idx].grid(True)

    fig.tight_layout()

# visualize(results)

def jobshop_model(TASKS):

    # Create the mip solver with the SCIP backend.
    m = pywraplp.Solver.CreateSolver('SCIP')

    # Define Sets
    JOBS = [j for (j,m) in TASKS] #check
    MACHINES = [m for (j,m) in TASKS.keys()]

    # establish an upper bound on makespan
    ub = sum(TASKS[t]['dur'] for t in TASKS.keys())

    # decision variables
    start = []
    auxilaryVar = []
    for t in TASKS.keys():
        suffix = '_%s' % str(t)
        start.append(m.NumVar(0, ub, 'start'))

        auxilaryVar_nested = []
        for tp in TASKS.keys():
            suffix = '_%s' % str(t)
            auxilaryVar_nested.append(m.BoolVar('z' ))
        auxilaryVar.append(auxilaryVar_nested)


    # additional decision variables for use in the objecive
    makespan = m.NumVar(0, ub, 'makespan')

    # constraints
    for t,task in enumerate(TASKS.keys()):
        m.Add(start[t] + TASKS[task]['dur'] <= makespan)

        for tp,taskp in enumerate(TASKS.keys()):
            if task == TASKS[taskp]['prec']:
                m.Add(start[t] + TASKS[task]['dur'] <= start[tp])

            if task[1] == taskp[1] and t < tp:  #same machine
                m.Add(start[t] + TASKS[task]['dur'] <= start[tp] + ub * auxilaryVar[t][tp])
                m.Add(start[tp] + TASKS[taskp]['dur'] <= start[t] + ub * (1-auxilaryVar[t][tp]))


    # objective function
    m.Minimize(makespan)
    status = m.Solve()

    if status == pywraplp.Solver.OPTIMAL:
        results = [{'Job': task[0],
                    'Machine': task[1],
                    'Start': start[t].solution_value(),
                    'Duration': TASKS[task]['dur'],
                    'Finish': start[t].solution_value() + TASKS[task]['dur']}
                     for t,task in enumerate(TASKS.keys())]

        results = []
        for t,task in enumerate(TASKS.keys()):
            results.append({'Job': task[0],
                    'Machine': task[1],
                    'Start': start[t].solution_value(),
                    'Duration': TASKS[task]['dur'],
                    'Finish': start[t].solution_value() + TASKS[task]['dur']})
        return results

    else:
        print('The problem does not have an optimal solution.')


results = jobshop_model(TASKS)
visualize(results)

def jobshop_model_zero_wait(TASKS):
    # Create the mip solver with the SCIP backend.
    m = pywraplp.Solver.CreateSolver('SCIP')
    if not m:
        return

    # Define Sets
    JOBS = list(set(j for (j, _) in TASKS))
    MACHINES = list(set(m for (_, m) in TASKS.keys()))

    # Establish an upper bound on makespan
    ub = sum(TASKS[t]['dur'] for t in TASKS.keys())

    # Decision variables
    start = {}
    auxilaryVar = {}
    for t in TASKS.keys():
        start[t] = m.NumVar(0, ub, f'start_{t}')
        for tp in TASKS.keys():
            if t != tp:
                auxilaryVar[(t, tp)] = m.BoolVar(f'aux_{t}_{tp}')

    # Additional decision variables for use in the objective
    makespan = m.NumVar(0, ub, 'makespan')

    # Constraints
    for t in TASKS.keys():
        m.Add(start[t] + TASKS[t]['dur'] <= makespan)

        if TASKS[t]['prec'] is not None:
            # Zero-wait constraint: start the next task immediately after the previous task ends
            m.Add(start[t] == start[TASKS[t]['prec']] + TASKS[TASKS[t]['prec']]['dur'])

    for t, tp in auxilaryVar.keys():
        if t[1] == tp[1]:  # same machine
            m.Add(start[t] + TASKS[t]['dur'] <= start[tp] + ub * auxilaryVar[(t, tp)])
            m.Add(start[tp] + TASKS[tp]['dur'] <= start[t] + ub * (1 - auxilaryVar[(t, tp)]))

    # Objective function
    m.Minimize(makespan)
    status = m.Solve()

    if status == pywraplp.Solver.OPTIMAL:
        results = [{'Job': t[0],
                    'Machine': t[1],
                    'Start': start[t].solution_value(),
                    'Duration': TASKS[t]['dur'],
                    'Finish': start[t].solution_value() + TASKS[t]['dur']}
                   for t in TASKS.keys()]
        return results
    else:
        print('The problem does not have an optimal solution.')
        return None

# Define tasks
TASKS = {
    ('Natural-Fiber Rug', 'Fiber Processing'): {'dur': 1.0, 'prec': None},
    ('Natural-Fiber Rug', 'Coloring'): {'dur': 5.0, 'prec': ('Natural-Fiber Rug', 'Fiber Processing')},
    ('Natural-Fiber Rug', 'Weaving'): {'dur': 4.0, 'prec': ('Natural-Fiber Rug', 'Coloring')},
    ('Natural-Fiber Rug', 'Inspection'): {'dur': 1.5, 'prec': ('Natural-Fiber Rug', 'Weaving')},
    ('Black & White Rug', 'Weaving'): {'dur': 4.5, 'prec': None},
    ('Black & White Rug', 'Inspection'): {'dur': 1.0, 'prec': ('Black & White Rug', 'Weaving')},
    ('Colored Rug', 'Coloring'): {'dur': 3.0, 'prec': None},
    ('Colored Rug', 'Weaving'): {'dur': 5.0, 'prec': ('Colored Rug', 'Coloring')},
    ('Colored Rug', 'Inspection'): {'dur': 1.5, 'prec': ('Colored Rug', 'Weaving')}
}

# Run the model with zero-wait constraint
results = jobshop_model_zero_wait(TASKS)
visualize(results)

TASKS = {
    # Natural-Fiber Rug Batches
    ('Natural-Fiber Rug Batch 1', 'Fiber Processing'): {'dur': 1.0, 'prec': None},
    ('Natural-Fiber Rug Batch 1', 'Coloring'): {'dur': 5.0, 'prec': ('Natural-Fiber Rug Batch 1', 'Fiber Processing')},
    ('Natural-Fiber Rug Batch 1', 'Weaving'): {'dur': 4.0, 'prec': ('Natural-Fiber Rug Batch 1', 'Coloring')},
    ('Natural-Fiber Rug Batch 1', 'Inspection'): {'dur': 1.5, 'prec': ('Natural-Fiber Rug Batch 1', 'Weaving')},
    ('Natural-Fiber Rug Batch 2', 'Fiber Processing'): {'dur': 1.0, 'prec': None},
    ('Natural-Fiber Rug Batch 2', 'Coloring'): {'dur': 5.0, 'prec': ('Natural-Fiber Rug Batch 2', 'Fiber Processing')},
    ('Natural-Fiber Rug Batch 2', 'Weaving'): {'dur': 4.0, 'prec': ('Natural-Fiber Rug Batch 2', 'Coloring')},
    ('Natural-Fiber Rug Batch 2', 'Inspection'): {'dur': 1.5, 'prec': ('Natural-Fiber Rug Batch 2', 'Weaving')},
    # Black & White Rug Batches
    ('Black & White Rug Batch 1', 'Weaving'): {'dur': 4.5, 'prec': None},
    ('Black & White Rug Batch 1', 'Inspection'): {'dur': 1.0, 'prec': ('Black & White Rug Batch 1', 'Weaving')},
    ('Black & White Rug Batch 2', 'Weaving'): {'dur': 4.5, 'prec': None},
    ('Black & White Rug Batch 2', 'Inspection'): {'dur': 1.0, 'prec': ('Black & White Rug Batch 2', 'Weaving')},
    # Colored Rug Batches
    ('Colored Rug Batch 1', 'Coloring'): {'dur': 3.0, 'prec': None},
    ('Colored Rug Batch 1', 'Weaving'): {'dur': 5.0, 'prec': ('Colored Rug Batch 1', 'Coloring')},
    ('Colored Rug Batch 1', 'Inspection'): {'dur': 1.5, 'prec': ('Colored Rug Batch 1', 'Weaving')},
    ('Colored Rug Batch 2', 'Coloring'): {'dur': 3.0, 'prec': None},
    ('Colored Rug Batch 2', 'Weaving'): {'dur': 5.0, 'prec': ('Colored Rug Batch 2', 'Coloring')},
    ('Colored Rug Batch 2', 'Inspection'): {'dur': 1.5, 'prec': ('Colored Rug Batch 2', 'Weaving')},
}

results = jobshop_model_zero_wait(TASKS)
visualize(results)

# Find the makespan
makespan = max(result['Finish'] for result in results)
print(f"The earliest time to deliver the 'NNBBCC' order is: {makespan} hours from the starting time.")

The earliest time to deliver the 'NNBBCC' order is: 28.0 hours from the starting time.

results = jobshop_model(TASKS)
visualize(results)

def jobshop_model_with_fiber_delay(TASKS, fiber_delay):
    # Create the mip solver with the SCIP backend.
    m = pywraplp.Solver.CreateSolver('SCIP')
    if not m:
        return

    # Define Sets
    JOBS = list(set(j for (j, _) in TASKS))
    MACHINES = list(set(m for (_, m) in TASKS.keys()))

    # Establish an upper bound on makespan
    ub = sum(TASKS[t]['dur'] for t in TASKS.keys())

    # Decision variables
    start = {}
    auxilaryVar = {}
    for t in TASKS.keys():
        start[t] = m.NumVar(0, ub, f'start_{t}')
        for tp in TASKS.keys():
            if t != tp:
                auxilaryVar[(t, tp)] = m.BoolVar(f'aux_{t}_{tp}')

    # Additional decision variables for use in the objective
    makespan = m.NumVar(0, ub, 'makespan')

    # Constraints
    for t in TASKS.keys():
        m.Add(start[t] + TASKS[t]['dur'] <= makespan)

        if TASKS[t]['prec'] is not None:
            # Ensure the task starts after its predecessor ends
            m.Add(start[t] >= start[TASKS[t]['prec']] + TASKS[TASKS[t]['prec']]['dur'])

    for t, tp in auxilaryVar.keys():
        if t[1] == tp[1]:  # same machine
            m.Add(start[t] + TASKS[t]['dur'] <= start[tp] + ub * auxilaryVar[(t, tp)])
            m.Add(start[tp] + TASKS[tp]['dur'] <= start[t] + ub * (1 - auxilaryVar[(t, tp)]))

    # Add fiber processing delay constraint
    for t in TASKS.keys():
        if t[1] == 'Fiber Processing':
            m.Add(start[t] >= fiber_delay)

    # Objective function
    m.Minimize(makespan)
    status = m.Solve()

    if status == pywraplp.Solver.OPTIMAL:
        results = [{'Job': t[0],
                    'Machine': t[1],
                    'Start': start[t].solution_value(),
                    'Duration': TASKS[t]['dur'],
                    'Finish': start[t].solution_value() + TASKS[t]['dur']}
                   for t in TASKS.keys()]
        return results
    else:
        print('The problem does not have an optimal solution.')
        return None

# Run the model with fiber processing delay
fiber_delay = 5  # Fiber processing section is available 5 time units after the process starts
results_fiber_delay = jobshop_model_with_fiber_delay(TASKS, fiber_delay)
visualize(results_fiber_delay)

# Find the makespan
makespan_fiber_delay = max(result['Finish'] for result in results_fiber_delay)
print(f"The makespan with fiber processing delay is: {makespan_fiber_delay} hours.")

The makespan with fiber processing delay is: 27.999999999999996 hours.

CLEANING_TIME = 1.0  # Time unit for cleaning between different rug types
def jobshop_model_with_cleaning(TASKS, fiber_delay, cleaning_time):
    # Create the mip solver with the SCIP backend.
    m = pywraplp.Solver.CreateSolver('SCIP')
    if not m:
        return

    # Define Sets
    JOBS = list(set(j for (j, _) in TASKS))
    MACHINES = list(set(m for (_, m) in TASKS.keys()))

    # Establish an upper bound on makespan
    ub = sum(TASKS[t]['dur'] for t in TASKS.keys()) + cleaning_time * (len(TASKS) - 1)

    # Decision variables
    start = {}
    auxilaryVar = {}
    for t in TASKS.keys():
        start[t] = m.NumVar(0, ub, f'start_{t}')
        for tp in TASKS.keys():
            if t != tp:
                auxilaryVar[(t, tp)] = m.BoolVar(f'aux_{t}_{tp}')

    # Additional decision variables for use in the objective
    makespan = m.NumVar(0, ub, 'makespan')

    # Constraints
    for t in TASKS.keys():
        m.Add(start[t] + TASKS[t]['dur'] <= makespan)

        if TASKS[t]['prec'] is not None:
            # Ensure the task starts after its predecessor ends
            m.Add(start[t] >= start[TASKS[t]['prec']] + TASKS[TASKS[t]['prec']]['dur'])

    for t, tp in auxilaryVar.keys():
        if t[1] == tp[1]:  # same machine
            if t[0].split()[0] != tp[0].split()[0]:  # Different rug types require cleaning
                m.Add(start[t] + TASKS[t]['dur'] + cleaning_time <= start[tp] + ub * auxilaryVar[(t, tp)])
            else:
                m.Add(start[t] + TASKS[t]['dur'] <= start[tp] + ub * auxilaryVar[(t, tp)])
            m.Add(start[tp] + TASKS[tp]['dur'] <= start[t] + ub * (1 - auxilaryVar[(t, tp)]))

    # Add fiber processing delay constraint
    for t in TASKS.keys():
        if t[1] == 'Fiber Processing':
            m.Add(start[t] >= fiber_delay)

    # Objective function
    m.Minimize(makespan)
    status = m.Solve()

    if status == pywraplp.Solver.OPTIMAL:
        results = [{'Job': t[0],
                    'Machine': t[1],
                    'Start': start[t].solution_value(),
                    'Duration': TASKS[t]['dur'],
                    'Finish': start[t].solution_value() + TASKS[t]['dur']}
                   for t in TASKS.keys()]
        return results
    else:
        print('The problem does not have an optimal solution.')
        return None

# Run the model with cleaning time constraint
fiber_delay = 5  # Fiber processing section is available 5 time units after the process starts
cleaning_time = 1.0  # Time unit for cleaning between different rug types
results_with_cleaning = jobshop_model_with_cleaning(TASKS, fiber_delay, cleaning_time)
visualize(results_with_cleaning)

# Find the makespan
makespan_with_cleaning = max(result['Finish'] for result in results_with_cleaning)
print(f"The makespan with cleaning time constraint is: {makespan_with_cleaning} hours.")

The makespan with cleaning time constraint is: 30.499999999999996 hours.

# Calculate the difference
difference_cleaning = makespan_with_cleaning - makespan_fiber_delay
print(f"Difference between fiber delay makespan and makespan with cleaning time constraint: {difference_cleaning} hours.")

Difference between fiber delay makespan and makespan with cleaning time constraint: 2.5 hours.

def jobshop_model_with_cleaning_and_zero_wait(TASKS, fiber_delay, cleaning_time):
    # Create the mip solver with the SCIP backend.
    m = pywraplp.Solver.CreateSolver('SCIP')
    if not m:
        return

    # Define Sets
    JOBS = list(set(j for (j, _) in TASKS))
    MACHINES = list(set(m for (_, m) in TASKS.keys()))

    # Establish an upper bound on makespan
    ub = sum(TASKS[t]['dur'] for t in TASKS.keys()) + cleaning_time * (len(TASKS) - 1)

    # Decision variables
    start = {}
    auxilaryVar = {}
    for t in TASKS.keys():
        start[t] = m.NumVar(0, ub, f'start_{t}')
        for tp in TASKS.keys():
            if t != tp:
                auxilaryVar[(t, tp)] = m.BoolVar(f'aux_{t}_{tp}')

    # Additional decision variables for use in the objective
    makespan = m.NumVar(0, ub, 'makespan')

    # Constraints
    for t in TASKS.keys():
        m.Add(start[t] + TASKS[t]['dur'] <= makespan)

        if TASKS[t]['prec'] is not None:
            # Zero-wait constraint: Ensure the next task starts immediately after the current task ends
            m.Add(start[t] == start[TASKS[t]['prec']] + TASKS[TASKS[t]['prec']]['dur'])

    for t, tp in auxilaryVar.keys():
        if t[1] == tp[1]:  # same machine
            if t[0].split()[0] != tp[0].split()[0]:  # Different rug types require cleaning
                m.Add(start[t] + TASKS[t]['dur'] + cleaning_time <= start[tp] + ub * auxilaryVar[(t, tp)])
            else:
                m.Add(start[t] + TASKS[t]['dur'] <= start[tp] + ub * auxilaryVar[(t, tp)])
            m.Add(start[tp] + TASKS[tp]['dur'] <= start[t] + ub * (1 - auxilaryVar[(t, tp)]))

    # Add fiber processing delay constraint
    for t in TASKS.keys():
        if t[1] == 'Fiber Processing':
            m.Add(start[t] >= fiber_delay)

    # Objective function
    m.Minimize(makespan)
    status = m.Solve()

    if status == pywraplp.Solver.OPTIMAL:
        results = [{'Job': t[0],
                    'Machine': t[1],
                    'Start': start[t].solution_value(),
                    'Duration': TASKS[t]['dur'],
                    'Finish': start[t].solution_value() + TASKS[t]['dur']}
                   for t in TASKS.keys()]
        return results
    else:
        print('The problem does not have an optimal solution.')
        return None

# Run the model with zero-wait, fiber delay, and cleaning time constraint
fiber_delay = 5  # Fiber processing section is available 5 time units after the process starts
cleaning_time = 1.0  # Time unit for cleaning between different rug types
results_with_cleaning_and_zero_wait = jobshop_model_with_cleaning_and_zero_wait(TASKS, fiber_delay, cleaning_time)
visualize(results_with_cleaning_and_zero_wait)

# Find the makespan
makespan_with_cleaning_and_zero_wait = max(result['Finish'] for result in results_with_cleaning_and_zero_wait)
print(f"The makespan with zero-wait, cleaning time, and fiber processing delay is: {makespan_with_cleaning_and_zero_wait} hours.")

The makespan with zero-wait, cleaning time, and fiber processing delay is: 31.5 hours.

Product/material	Table	Tabletop	Leg	Beams	Screws	Planks	Brackets	Glue
Lead-time	3	2	2	3	1	1	1	1
Initial inventory	0	20	100	70	50	100	50	100
Production cost	100	100	100	100	100	100	100	100
Inventory cost	20	10	10	10	5	5	5	5
Setup cost	500	200	200	200	200	200	200	200

	0	1	3	4	5	8	9	10	11	12	13	14
product 0	20.0	-0.0	13.0	16.0	55.0	0.0	53.0	0.0	0.0	0.0	0.0	0.0
setup	1.0	0.0	1.0	1.0	1.0	0.0	1.0	0.0	0.0	0.0	0.0	0.0
inventory	0.0	0.0	20.0	20.0	2.0	43.0	29.0	10.0	-0.0	40.0	29.0	12.0

	0	1	2	3	7
product 1	6.0	7.0	16.0	55.0	53.0
setup	1.0	1.0	1.0	1.0	1.0
inventory	0.0	0.0	6.0	0.0	0.0

	0	1	2	3	7
product 2	0.0	33.0	63.0	220.0	212.0
setup	0.0	1.0	1.0	1.0	1.0
inventory	20.0	20.0	20.0	0.0	0.0

	0	1	2	3	6
product 3	0.0	28.0	110.0	0.0	106.0
setup	0.0	1.0	1.0	0.0	1.0
inventory	30.0	30.0	30.0	4.0	0.0

	0	1	2	5	6
product 4	429.0	1073.0	2200.0	424.0	2120.0
setup	1.0	1.0	1.0	1.0	1.0
inventory	0.0	0.0	0.0	0.0	0.0

	0	1	2	5	6
product 5	100.0	489.0	935.0	212.0	901.0
setup	1.0	1.0	1.0	1.0	1.0
inventory	94.0	0.0	0.0	0.0	0.0

	0	1	2	5	6
product 6	246.0	756.0	1100.0	424.0	1060.0
setup	1.0	1.0	1.0	1.0	1.0
inventory	25.0	0.0	0.0	0.0	0.0

	0	1	2	4	5	6
product 7	550.0	1108.0	220.0	212.0	1007.0	212.0
setup	1.0	1.0	1.0	1.0	1.0	1.0
inventory	0.0	0.0	0.0	0.0	0.0	0.0

	0	1	2	4	5	7	9
product 0	32.0	0.0	112.0	56.0	116.0	96.0	116.0
setup	1.0	0.0	1.0	1.0	1.0	1.0	1.0
inventory	100.0	100.0	0.0	0.0	0.0	0.0	0.0

	0	1	2	3	4	6	7	8	10	11	12	13	14	15
product 0	0.0	52.0	0.0	28.0	58.0	48.0	-0.0	58.0	0.0	0.0	0.0	0.0	0.0	0.0
setup	0.0	1.0	0.0	1.0	1.0	1.0	0.0	1.0	0.0	0.0	0.0	0.0	0.0	0.0
inventory	70.0	70.0	4.0	4.0	0.0	0.0	0.0	0.0	-0.0	-0.0	-0.0	-0.0	-0.0	-0.0

	0	1	2	3	5	6	7	10	11	12	13	14
product 3	0.0	28.0	132.0	0.0	-0.0	113.0	31.0	0.0	0.0	0.0	0.0	0.0
setup	0.0	1.0	1.0	0.0	0.0	1.0	1.0	0.0	0.0	0.0	0.0	0.0
inventory	30.0	30.0	30.0	4.0	17.0	10.0	6.0	28.0	22.0	17.0	13.0	6.0

	0	1	2	4	5	6	7	11
product 4	429.0	1161.0	2200.0	-0.0	452.0	2244.0	-0.0	-0.0
setup	1.0	1.0	1.0	0.0	1.0	1.0	0.0	0.0
inventory	-0.0	-0.0	0.0	0.0	0.0	0.0	0.0	0.0

	0	1	2	4	5	6	7	10	11
product 5	100.0	533.0	935.0	-0.0	226.0	963.0	0.0	-0.0	0.0
setup	1.0	1.0	1.0	0.0	1.0	1.0	0.0	0.0	0.0
inventory	94.0	0.0	0.0	0.0	0.0	0.0	-0.0	0.0	-0.0

	0	1	2	4	5	6	7
product 6	246.0	844.0	1100.0	-0.0	452.0	1184.0	-0.0
setup	1.0	1.0	1.0	0.0	1.0	1.0	0.0
inventory	25.0	0.0	0.0	0.0	0.0	0.0	0.0

	0	1	2	3	4	5	6	9
product 7	594.0	1130.0	220.0	-0.0	226.0	1076.0	243.0	-0.0
setup	1.0	1.0	1.0	0.0	1.0	1.0	1.0	0.0
inventory	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0

Period	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16
Table	100	100	100	100	200	200	200	200	200	100	100	100	100	100	100	100
Table-top	30	30	30	30	60	60	60	60	60	30	30	30	30	30	30	30
Leg	40	40	40	40	80	80	80	80	80	40	40	40	40	40	40	40
Beams	70	70	70	70	140	140	140	140	140	70	70	70	70	70	70	70
Screws	40	40	40	40	40	40	40	40	40	40	40	40	40	40	40	40
Plank	60	60	60	60	60	60	60	60	60	60	60	60	60	60	60	60
Brackets	80	80	80	80	80	80	80	80	80	80	80	80	80	80	80	80
Glue	30	30	30	30	30	30	30	30	30	30	30	30	30	30	30	30

	0	1	2	3	9	11
product 1	6.0	7.0	16.0	79.0	29.0	0.0
setup	1.0	1.0	1.0	1.0	1.0	0.0
inventory	0.0	0.0	6.0	0.0	0.0	12.0

	0	1	2	3	5	6	7	8	9	10
product 3	0.0	28.0	158.0	34.0	0.0	0.0	0.0	0.0	24.0	0.0
setup	0.0	1.0	1.0	1.0	0.0	0.0	0.0	0.0	1.0	0.0
inventory	30.0	30.0	30.0	4.0	-0.0	34.0	34.0	34.0	34.0	34.0

	0	1	2	8
product 4	429.0	1265.0	3296.0	1256.0
setup	1.0	1.0	1.0	1.0
inventory	0.0	0.0	0.0	0.0

Setup¶

Context¶

PART I : Production Planning¶

BOM¶

Table 1: Demand of new Table in the upcoming 16 days¶

Table 2: Information regarding production of the new table¶

Question 1¶

Setting up data and the optimization function¶

Using integrated model to find Optimum¶

Using Decomposition approach to observe¶

MPS¶

MRP¶

table top¶

Leg¶

Beams¶

Screws¶

Plank¶

Brackets¶

Glue¶

Question 2¶

Question 3¶

Question 4¶

Question 5¶

Question 6¶

Question 7¶

setup cost of 10000¶

Varying setup cost between 500 and 10000 by 500 intervals¶

Question 8¶

MPS¶

MRP¶

Table top¶

Leg¶

Beams¶

Question 9¶

PART II : Schedulling¶

Question 1¶

MILP¶

LPT¶

WSPT¶

SPT¶

Flow time¶

Table of order based on each rules¶

Question 2¶

MILP¶

LPT¶

Question 3¶

3.1¶

SPT¶

EDD¶

3.2¶

Mathematical model¶

Max lateness¶

Number of delayed jobs¶

Moore and Hudson Algo¶

3.3¶

Question 4¶

Constraints Description¶

Parameters and Variables¶

Optimization Model¶

Additional Constraints Needed¶

Integration of the Additional Constraints¶

Justification¶

Course Reference¶

Question 6¶

LPT¶

SPT¶

EDD¶

Question 7¶

Question 8¶

Question 9¶

Question 10¶

Question 11¶

Question 12¶

Question 13¶

	0	1	2	8
product 5	100.0	585.0	1411.0	541.0
setup	1.0	1.0	1.0	1.0
inventory	94.0	0.0	0.0	0.0

	0	1	2	8
product 6	246.0	948.0	1716.0	676.0
setup	1.0	1.0	1.0	1.0
inventory	25.0	0.0	0.0	0.0

	0	1	2	7	8
product 7	646.0	1632.0	350.0	541.0	140.0
setup	1.0	1.0	1.0	1.0	1.0
inventory	0.0	0.0	0.0	0.0	0.0

	0	1	2	3	6	7	8	9	10	11	12	13	14
product 3	0.0	28.0	163.0	67.0	0.0	0.0	0.0	46.0	0.0	-0.0	0.0	0.0	0.0
setup	0.0	1.0	1.0	1.0	0.0	0.0	0.0	1.0	0.0	0.0	0.0	0.0	0.0
inventory	30.0	30.0	30.0	4.0	60.0	56.0	50.0	43.0	40.0	0.0	17.0	13.0	6.0

	0	1	2	6	8	9	10
product 4	429.0	1285.0	3428.0	-0.0	1344.0	-0.0	-0.0
setup	1.0	1.0	1.0	0.0	1.0	0.0	0.0
inventory	0.0	0.0	0.0	0.0	0.0	0.0	0.0

	0	1	2	6	8	9	10
product 5	100.0	595.0	1477.0	-0.0	585.0	-0.0	-0.0
setup	1.0	1.0	1.0	0.0	1.0	0.0	0.0
inventory	94.0	0.0	0.0	0.0	0.0	0.0	0.0

	0	1	2	6	8	9	10
product 6	246.0	968.0	1848.0	-0.0	764.0	-0.0	-0.0
setup	1.0	1.0	1.0	0.0	1.0	0.0	0.0
inventory	25.0	0.0	0.0	0.0	0.0	0.0	0.0

	0	1	2	5	6	7	8	9	10
product 7	656.0	1703.0	383.0	-0.0	-0.0	585.0	162.0	-0.0	-0.0
setup	1.0	1.0	1.0	0.0	0.0	1.0	1.0	0.0	0.0
inventory	0.0	0.0	0.0	0.0	0.0	0.0	-0.0	0.0	0.0

	0	1	2	3
product 1	6.0	7.0	16.0	108.0
setup	1.0	1.0	1.0	1.0
inventory	0.0	0.0	6.0	0.0

	0	1	2	3	6	7	8	9	10	11	12	13	14
product 3	0.0	28.0	221.0	33.0	0.0	0.0	0.0	22.0	-0.0	0.0	-0.0	0.0	0.0
setup	0.0	1.0	1.0	1.0	0.0	0.0	0.0	1.0	0.0	0.0	0.0	0.0	0.0
inventory	30.0	30.0	30.0	4.0	26.0	22.0	16.0	9.0	6.0	-0.0	17.0	13.0	6.0